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
 426 #include <dali/public-api/math/matrix.h>
 427 #include <dali/public-api/math/matrix3.h>
 428 #include <dali/public-api/math/viewport.h>
 429 #include <dali/public-api/object/property-key.h>
 430
 431 #include <dali/public-api/adaptor-framework/timer.h>
 432 #include <dali/public-api/adaptor-framework/window.h>
 433 #include <dali/public-api/adaptor-framework/style-change.h>
 434 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 435 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 436
 437 #include <dali/devel-api/images/nine-patch-image.h>
 438
 439 #include <dali-toolkit/devel-api/builder/builder.h>
 440
 441 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 442
 443 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 444 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 445 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 446 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 447 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 448 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 450
 451 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 452 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 453 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 454
 455 //this should be fixed after tizen branch being upgraded!
 456 //#include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 457
 458 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 459
 460 // add here SWIG version check
 461
 462 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 463 // disable Swig-dependent warnings
 464
 465 // 'identifier1' has C-linkage specified,
 466 // but returns UDT 'identifier2' which is incompatible with C
 467 #pragma warning(disable: 4190)
 468
 469 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 470 #pragma warning(disable: 4800)
 471
 472 // debug info too long etc etc
 473 #pragma warning(disable: 4786)
 474 #endif
 475
 476
 477 #include <stdexcept>
 478
 479
 480 #include <string>
 481
 482
 483 #include <vector>
 484 #include <algorithm>
 485 #include <stdexcept>
 486
 487
 488 #include <map>
 489 #include <algorithm>
 490 #include <stdexcept>
 491
 492
 493 #include <utility>
 494
 495
 496 typedef float floatp;
 497
 498 SWIGINTERN floatp *new_floatp(){
 499   return new float();
 500 }
 501 SWIGINTERN void delete_floatp(floatp *self){
 502   if (self) delete self;
 503 }
 504 SWIGINTERN void floatp_assign(floatp *self,float value){
 505   *self = value;
 506 }
 507 SWIGINTERN float floatp_value(floatp *self){
 508   return *self;
 509 }
 510 SWIGINTERN float *floatp_cast(floatp *self){
 511   return self;
 512 }
 513 SWIGINTERN floatp *floatp_frompointer(float *t){
 514   return (floatp *) t;
 515 }
 516
 517 typedef int intp;
 518
 519 SWIGINTERN intp *new_intp(){
 520   return new int();
 521 }
 522 SWIGINTERN void delete_intp(intp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void intp_assign(intp *self,int value){
 526   *self = value;
 527 }
 528 SWIGINTERN int intp_value(intp *self){
 529   return *self;
 530 }
 531 SWIGINTERN int *intp_cast(intp *self){
 532   return self;
 533 }
 534 SWIGINTERN intp *intp_frompointer(int *t){
 535   return (intp *) t;
 536 }
 537
 538 typedef double doublep;
 539
 540 SWIGINTERN doublep *new_doublep(){
 541   return new double();
 542 }
 543 SWIGINTERN void delete_doublep(doublep *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void doublep_assign(doublep *self,double value){
 547   *self = value;
 548 }
 549 SWIGINTERN double doublep_value(doublep *self){
 550   return *self;
 551 }
 552 SWIGINTERN double *doublep_cast(doublep *self){
 553   return self;
 554 }
 555 SWIGINTERN doublep *doublep_frompointer(double *t){
 556   return (doublep *) t;
 557 }
 558
 559 typedef unsigned int uintp;
 560
 561 SWIGINTERN uintp *new_uintp(){
 562   return new unsigned int();
 563 }
 564 SWIGINTERN void delete_uintp(uintp *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 568   *self = value;
 569 }
 570 SWIGINTERN unsigned int uintp_value(uintp *self){
 571   return *self;
 572 }
 573 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 574   return self;
 575 }
 576 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 577   return (uintp *) t;
 578 }
 579
 580 typedef unsigned short ushortp;
 581
 582 SWIGINTERN ushortp *new_ushortp(){
 583   return new unsigned short();
 584 }
 585 SWIGINTERN void delete_ushortp(ushortp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 595   return self;
 596 }
 597 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 598   return (ushortp *) t;
 599 }
 600
 601 unsigned int int_to_uint(int x) {
 602    return (unsigned int) x;
 603 }
 604
 605
 606 using namespace Dali;
 607 using namespace Dali::Toolkit;
 608
 609 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 610
 611      // C++ code. DALi uses Handle <-> Body design pattern.
 612      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 613      // Handles in DALi can be converted into a boolean type
 614      // to check if the handle has a valid body attached to it.
 615      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 616      if( *self )
 617      {
 618        return true;
 619      }
 620      else
 621      {
 622        return false;
 623      }
 624     }
 625 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 626
 627      // C++ code. Check if two handles reference the same implemtion
 628      if( *self == rhs)
 629      {
 630        return true;
 631      }
 632      else
 633      {
 634        return false;
 635      }
 636     }
 637 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 638         std::vector< Dali::TouchPoint >* pv = 0;
 639         if (capacity >= 0) {
 640           pv = new std::vector< Dali::TouchPoint >();
 641           pv->reserve(capacity);
 642        } else {
 643           throw std::out_of_range("capacity");
 644        }
 645        return pv;
 646       }
 647 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 648         if (index>=0 && index<(int)self->size())
 649           return (*self)[index];
 650         else
 651           throw std::out_of_range("index");
 652       }
 653 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 654         if (index>=0 && index<(int)self->size())
 655           return (*self)[index];
 656         else
 657           throw std::out_of_range("index");
 658       }
 659 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 660         if (index>=0 && index<(int)self->size())
 661           (*self)[index] = val;
 662         else
 663           throw std::out_of_range("index");
 664       }
 665 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 666         self->insert(self->end(), values.begin(), values.end());
 667       }
 668 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 669         if (index < 0)
 670           throw std::out_of_range("index");
 671         if (count < 0)
 672           throw std::out_of_range("count");
 673         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 674           throw std::invalid_argument("invalid range");
 675         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 678         if (index>=0 && index<(int)self->size()+1)
 679           self->insert(self->begin()+index, x);
 680         else
 681           throw std::out_of_range("index");
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 684         if (index>=0 && index<(int)self->size()+1)
 685           self->insert(self->begin()+index, values.begin(), values.end());
 686         else
 687           throw std::out_of_range("index");
 688       }
 689 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 690         if (index>=0 && index<(int)self->size())
 691           self->erase(self->begin() + index);
 692         else
 693           throw std::out_of_range("index");
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 696         if (index < 0)
 697           throw std::out_of_range("index");
 698         if (count < 0)
 699           throw std::out_of_range("count");
 700         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 701           throw std::invalid_argument("invalid range");
 702         self->erase(self->begin()+index, self->begin()+index+count);
 703       }
 704 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 705         if (count < 0)
 706           throw std::out_of_range("count");
 707         return new std::vector< Dali::TouchPoint >(count, value);
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 710         std::reverse(self->begin(), self->end());
 711       }
 712 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 713         if (index < 0)
 714           throw std::out_of_range("index");
 715         if (count < 0)
 716           throw std::out_of_range("count");
 717         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 718           throw std::invalid_argument("invalid range");
 719         std::reverse(self->begin()+index, self->begin()+index+count);
 720       }
 721 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 722         if (index < 0)
 723           throw std::out_of_range("index");
 724         if (index+values.size() > self->size())
 725           throw std::out_of_range("index");
 726         std::copy(values.begin(), values.end(), self->begin()+index);
 727       }
 728 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 729          return self->Empty();
 730       }
 731 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 732         return self->GetConnectionCount();
 733       }
 734 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 735           self->Connect( func );
 736       }
 737 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 738           self->Disconnect( func );
 739       }
 740 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 741           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 742 /*@SWIG@*/ self->Emit( arg );
 743       }
 744 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 745          return self->Empty();
 746       }
 747 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 748         return self->GetConnectionCount();
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 751           self->Connect( func );
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 754           self->Disconnect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 757           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 758 /*@SWIG@*/ self->Emit( arg );
 759       }
 760 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 761          return self->Empty();
 762       }
 763 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){
 764         return self->GetConnectionCount();
 765       }
 766 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 *)){
 767           self->Connect( func );
 768       }
 769 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 *)){
 770           self->Disconnect( func );
 771       }
 772 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){
 773           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 774 /*@SWIG@*/ self->Emit( arg );
 775       }
 776 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 777          return self->Empty();
 778       }
 779 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 780         return self->GetConnectionCount();
 781       }
 782 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 783           self->Connect( func );
 784       }
 785 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 786           self->Disconnect( func );
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 789           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 790 /*@SWIG@*/ self->Emit( arg );
 791       }
 792 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 793          return self->Empty();
 794       }
 795 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 796         return self->GetConnectionCount();
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 799           self->Connect( func );
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 802           self->Disconnect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 805           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 806 /*@SWIG@*/ self->Emit( arg );
 807       }
 808 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){
 809          return self->Empty();
 810       }
 811 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){
 812         return self->GetConnectionCount();
 813       }
 814 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 &)){
 815         self->Connect( func );
 816       }
 817 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 &)){
 818         self->Disconnect( func );
 819       }
 820 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){
 821         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg1, arg2 );
 823       }
 824 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){
 825          return self->Empty();
 826       }
 827 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){
 828         return self->GetConnectionCount();
 829       }
 830 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 &)){
 831         self->Connect( func );
 832       }
 833 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 &)){
 834         self->Disconnect( func );
 835       }
 836 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){
 837         return self->Emit( arg1, arg2 );
 838       }
 839 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){
 840          return self->Empty();
 841       }
 842 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){
 843         return self->GetConnectionCount();
 844       }
 845 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 &)){
 846         self->Connect( func );
 847       }
 848 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 &)){
 849         self->Disconnect( func );
 850       }
 851 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){
 852         return self->Emit( arg1, arg2 );
 853       }
 854 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){
 855          return self->Empty();
 856       }
 857 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){
 858         return self->GetConnectionCount();
 859       }
 860 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 &)){
 861         self->Connect( func );
 862       }
 863 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 &)){
 864         self->Disconnect( func );
 865       }
 866 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){
 867         return self->Emit( arg1, arg2 );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 876           self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 879           self->Disconnect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 882           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 883 /*@SWIG@*/ self->Emit( arg );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 886          return self->Empty();
 887       }
 888 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){
 889         return self->GetConnectionCount();
 890       }
 891 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 &)){
 892           self->Connect( func );
 893       }
 894 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 &)){
 895           self->Disconnect( func );
 896       }
 897 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){
 898           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg );
 900       }
 901 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908           self->Connect( func );
 909       }
 910 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 &)){
 911           self->Disconnect( func );
 912       }
 913 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){
 914           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 915 /*@SWIG@*/ self->Emit( arg );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924           self->Connect( func );
 925       }
 926 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 &)){
 927           self->Disconnect( func );
 928       }
 929 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){
 930           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 931 /*@SWIG@*/ self->Emit( arg );
 932       }
 933 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){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940         self->Connect( func );
 941       }
 942 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 &)){
 943         self->Disconnect( func );
 944       }
 945 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){
 946         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 947 /*@SWIG@*/ self->Emit( arg1, arg2 );
 948       }
 949 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){
 950          return self->Empty();
 951       }
 952 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){
 953         return self->GetConnectionCount();
 954       }
 955 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 &)){
 956         self->Connect( func );
 957       }
 958 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 &)){
 959         self->Disconnect( func );
 960       }
 961 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){
 962         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg1, arg2 );
 964       }
 965 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){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972         self->Connect( func );
 973       }
 974 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 &)){
 975         self->Disconnect( func );
 976       }
 977 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){
 978         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg1, arg2 );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 982          return self->Empty();
 983       }
 984 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 985         return self->GetConnectionCount();
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 988           self->Connect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 991           self->Disconnect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013
1014   // keep argcs and argv so they're always available to DALi
1015   int argC = 1;
1016   char **argV = NULL;
1017
1018 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1019          return self->Empty();
1020       }
1021 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1022         return self->GetConnectionCount();
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1025           self->Connect( func );
1026       }
1027 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1028           self->Disconnect( func );
1029       }
1030 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1031           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1032 /*@SWIG@*/ self->Emit( arg );
1033       }
1034 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1035          return self->Empty();
1036       }
1037 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){
1038         return self->GetConnectionCount();
1039       }
1040 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 *)){
1041         self->Connect( func );
1042       }
1043 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 *)){
1044         self->Disconnect( func );
1045       }
1046 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){
1047         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1048 /*@SWIG@*/ self->Emit( arg1, arg2 );
1049       }
1050 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1051         std::vector< unsigned int >* pv = 0;
1052         if (capacity >= 0) {
1053           pv = new std::vector< unsigned int >();
1054           pv->reserve(capacity);
1055        } else {
1056           throw std::out_of_range("capacity");
1057        }
1058        return pv;
1059       }
1060 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1061         if (index>=0 && index<(int)self->size())
1062           return (*self)[index];
1063         else
1064           throw std::out_of_range("index");
1065       }
1066 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1067         if (index>=0 && index<(int)self->size())
1068           return (*self)[index];
1069         else
1070           throw std::out_of_range("index");
1071       }
1072 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1073         if (index>=0 && index<(int)self->size())
1074           (*self)[index] = val;
1075         else
1076           throw std::out_of_range("index");
1077       }
1078 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1079         self->insert(self->end(), values.begin(), values.end());
1080       }
1081 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1082         if (index < 0)
1083           throw std::out_of_range("index");
1084         if (count < 0)
1085           throw std::out_of_range("count");
1086         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1087           throw std::invalid_argument("invalid range");
1088         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1089       }
1090 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1091         if (index>=0 && index<(int)self->size()+1)
1092           self->insert(self->begin()+index, x);
1093         else
1094           throw std::out_of_range("index");
1095       }
1096 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1097         if (index>=0 && index<(int)self->size()+1)
1098           self->insert(self->begin()+index, values.begin(), values.end());
1099         else
1100           throw std::out_of_range("index");
1101       }
1102 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1103         if (index>=0 && index<(int)self->size())
1104           self->erase(self->begin() + index);
1105         else
1106           throw std::out_of_range("index");
1107       }
1108 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1109         if (index < 0)
1110           throw std::out_of_range("index");
1111         if (count < 0)
1112           throw std::out_of_range("count");
1113         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1114           throw std::invalid_argument("invalid range");
1115         self->erase(self->begin()+index, self->begin()+index+count);
1116       }
1117 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1118         if (count < 0)
1119           throw std::out_of_range("count");
1120         return new std::vector< unsigned int >(count, value);
1121       }
1122 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1123         std::reverse(self->begin(), self->end());
1124       }
1125 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1126         if (index < 0)
1127           throw std::out_of_range("index");
1128         if (count < 0)
1129           throw std::out_of_range("count");
1130         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1131           throw std::invalid_argument("invalid range");
1132         std::reverse(self->begin()+index, self->begin()+index+count);
1133       }
1134 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1135         if (index < 0)
1136           throw std::out_of_range("index");
1137         if (index+values.size() > self->size())
1138           throw std::out_of_range("index");
1139         std::copy(values.begin(), values.end(), self->begin()+index);
1140       }
1141 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1142         return std::find(self->begin(), self->end(), value) != self->end();
1143       }
1144 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1145         int index = -1;
1146         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1147         if (it != self->end())
1148           index = (int)(it - self->begin());
1149         return index;
1150       }
1151 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1152         int index = -1;
1153         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1154         if (rit != self->rend())
1155           index = (int)(self->rend() - 1 - rit);
1156         return index;
1157       }
1158 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1159         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1160         if (it != self->end()) {
1161           self->erase(it);
1162           return true;
1163         }
1164         return false;
1165       }
1166 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){
1167         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1168         if (capacity >= 0) {
1169           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1170           pv->reserve(capacity);
1171        } else {
1172           throw std::out_of_range("capacity");
1173        }
1174        return pv;
1175       }
1176 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){
1177         if (index>=0 && index<(int)self->size())
1178           return (*self)[index];
1179         else
1180           throw std::out_of_range("index");
1181       }
1182 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){
1183         if (index>=0 && index<(int)self->size())
1184           return (*self)[index];
1185         else
1186           throw std::out_of_range("index");
1187       }
1188 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){
1189         if (index>=0 && index<(int)self->size())
1190           (*self)[index] = val;
1191         else
1192           throw std::out_of_range("index");
1193       }
1194 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){
1195         self->insert(self->end(), values.begin(), values.end());
1196       }
1197 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){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1205       }
1206 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){
1207         if (index>=0 && index<(int)self->size()+1)
1208           self->insert(self->begin()+index, x);
1209         else
1210           throw std::out_of_range("index");
1211       }
1212 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){
1213         if (index>=0 && index<(int)self->size()+1)
1214           self->insert(self->begin()+index, values.begin(), values.end());
1215         else
1216           throw std::out_of_range("index");
1217       }
1218 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){
1219         if (index>=0 && index<(int)self->size())
1220           self->erase(self->begin() + index);
1221         else
1222           throw std::out_of_range("index");
1223       }
1224 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){
1225         if (index < 0)
1226           throw std::out_of_range("index");
1227         if (count < 0)
1228           throw std::out_of_range("count");
1229         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1230           throw std::invalid_argument("invalid range");
1231         self->erase(self->begin()+index, self->begin()+index+count);
1232       }
1233 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){
1234         if (count < 0)
1235           throw std::out_of_range("count");
1236         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1237       }
1238 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){
1239         std::reverse(self->begin(), self->end());
1240       }
1241 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){
1242         if (index < 0)
1243           throw std::out_of_range("index");
1244         if (count < 0)
1245           throw std::out_of_range("count");
1246         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1247           throw std::invalid_argument("invalid range");
1248         std::reverse(self->begin()+index, self->begin()+index+count);
1249       }
1250 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){
1251         if (index < 0)
1252           throw std::out_of_range("index");
1253         if (index+values.size() > self->size())
1254           throw std::out_of_range("index");
1255         std::copy(values.begin(), values.end(), self->begin()+index);
1256       }
1257 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1258         std::vector< Dali::Actor >* pv = 0;
1259         if (capacity >= 0) {
1260           pv = new std::vector< Dali::Actor >();
1261           pv->reserve(capacity);
1262        } else {
1263           throw std::out_of_range("capacity");
1264        }
1265        return pv;
1266       }
1267 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1268         if (index>=0 && index<(int)self->size())
1269           return (*self)[index];
1270         else
1271           throw std::out_of_range("index");
1272       }
1273 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1274         if (index>=0 && index<(int)self->size())
1275           return (*self)[index];
1276         else
1277           throw std::out_of_range("index");
1278       }
1279 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1280         if (index>=0 && index<(int)self->size())
1281           (*self)[index] = val;
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1286         self->insert(self->end(), values.begin(), values.end());
1287       }
1288 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1289         if (index < 0)
1290           throw std::out_of_range("index");
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1294           throw std::invalid_argument("invalid range");
1295         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1296       }
1297 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1298         if (index>=0 && index<(int)self->size()+1)
1299           self->insert(self->begin()+index, x);
1300         else
1301           throw std::out_of_range("index");
1302       }
1303 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1304         if (index>=0 && index<(int)self->size()+1)
1305           self->insert(self->begin()+index, values.begin(), values.end());
1306         else
1307           throw std::out_of_range("index");
1308       }
1309 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1310         if (index>=0 && index<(int)self->size())
1311           self->erase(self->begin() + index);
1312         else
1313           throw std::out_of_range("index");
1314       }
1315 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (count < 0)
1319           throw std::out_of_range("count");
1320         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1321           throw std::invalid_argument("invalid range");
1322         self->erase(self->begin()+index, self->begin()+index+count);
1323       }
1324 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1325         if (count < 0)
1326           throw std::out_of_range("count");
1327         return new std::vector< Dali::Actor >(count, value);
1328       }
1329 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1330         std::reverse(self->begin(), self->end());
1331       }
1332 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1333         if (index < 0)
1334           throw std::out_of_range("index");
1335         if (count < 0)
1336           throw std::out_of_range("count");
1337         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1338           throw std::invalid_argument("invalid range");
1339         std::reverse(self->begin()+index, self->begin()+index+count);
1340       }
1341 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1342         if (index < 0)
1343           throw std::out_of_range("index");
1344         if (index+values.size() > self->size())
1345           throw std::out_of_range("index");
1346         std::copy(values.begin(), values.end(), self->begin()+index);
1347       }
1348 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1349          return self->Empty();
1350       }
1351 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1352         return self->GetConnectionCount();
1353       }
1354 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 &)){
1355           self->Connect( func );
1356       }
1357 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 &)){
1358           self->Disconnect( func );
1359       }
1360 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){
1361           return self->Emit( arg );
1362       }
1363 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
1364          return self->Empty();
1365       }
1366 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
1367         return self->GetConnectionCount();
1368       }
1369 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
1370         self->Connect( func );
1371       }
1372 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
1373         self->Disconnect( func );
1374       }
1375 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,Dali::Toolkit::AccessibilityManager &arg1,Dali::TouchEvent const &arg2){
1376         return self->Emit( arg1, arg2 );
1377       }
1378 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){
1379          return self->Empty();
1380       }
1381 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){
1382         return self->GetConnectionCount();
1383       }
1384 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)){
1385         self->Connect( func );
1386       }
1387 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)){
1388         self->Disconnect( func );
1389       }
1390 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){
1391         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1392 /*@SWIG@*/ self->Emit( arg1, arg2 );
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1395          return self->Empty();
1396       }
1397 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){
1398         return self->GetConnectionCount();
1399       }
1400 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)){
1401         self->Connect( func );
1402       }
1403 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)){
1404         self->Disconnect( func );
1405       }
1406 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){
1407         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1408 /*@SWIG@*/ self->Emit( arg1, arg2 );
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1411          return self->Empty();
1412       }
1413 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1414         return self->GetConnectionCount();
1415       }
1416 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)){
1417         self->Connect( func );
1418       }
1419 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)){
1420         self->Disconnect( func );
1421       }
1422 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){
1423         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1424 /*@SWIG@*/ self->Emit( arg1, arg2 );
1425       }
1426 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){
1427          return self->Empty();
1428       }
1429 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){
1430         return self->GetConnectionCount();
1431       }
1432 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)){
1433         self->Connect( func );
1434       }
1435 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)){
1436         self->Disconnect( func );
1437       }
1438 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){
1439         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1440 /*@SWIG@*/ self->Emit( arg1, arg2 );
1441       }
1442 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1443          return self->Empty();
1444       }
1445 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1446         return self->GetConnectionCount();
1447       }
1448 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)){
1449           self->Connect( func );
1450       }
1451 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)){
1452           self->Disconnect( func );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1455           return self->Emit( arg );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464           self->Connect( func );
1465       }
1466 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)){
1467           self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1470           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg );
1472       }
1473 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){
1474          return self->Empty();
1475       }
1476 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){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           return self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 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){
1486           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1488       }
1489 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1490          return self->Empty();
1491       }
1492 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1502           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg );
1504       }
1505 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){
1506          return self->Empty();
1507       }
1508 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){
1509         return self->GetConnectionCount();
1510       }
1511 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 &)){
1512           self->Connect( func );
1513       }
1514 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 &)){
1515           self->Disconnect( func );
1516       }
1517 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){
1518           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1519 /*@SWIG@*/ self->Emit( arg );
1520       }
1521 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1522          return self->Empty();
1523       }
1524 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){
1525         return self->GetConnectionCount();
1526       }
1527 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 &)){
1528           self->Connect( func );
1529       }
1530 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 &)){
1531           self->Disconnect( func );
1532       }
1533 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){
1534           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1535 /*@SWIG@*/ self->Emit( arg );
1536       }
1537 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1538          return self->Empty();
1539       }
1540 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1541         return self->GetConnectionCount();
1542       }
1543 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)){
1544           self->Connect( func );
1545       }
1546 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)){
1547           self->Disconnect( func );
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1550           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1551 /*@SWIG@*/ self->Emit( arg );
1552       }
1553 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1554          return self->Empty();
1555       }
1556 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1557         return self->GetConnectionCount();
1558       }
1559 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)){
1560           self->Connect( func );
1561       }
1562 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)){
1563           self->Disconnect( func );
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1566           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1567 /*@SWIG@*/ self->Emit( arg );
1568       }
1569 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){
1570          return self->Empty();
1571       }
1572 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){
1573         return self->GetConnectionCount();
1574       }
1575 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 &)){
1576         self->Connect( func );
1577       }
1578 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 &)){
1579         self->Disconnect( func );
1580       }
1581 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){
1582         return self->Emit( arg1, arg2 );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1585          return self->Empty();
1586       }
1587 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1588         return self->GetConnectionCount();
1589       }
1590 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)){
1591           self->Connect( func );
1592       }
1593 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)){
1594           self->Disconnect( func );
1595       }
1596 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1601          return self->Empty();
1602       }
1603 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1604         return self->GetConnectionCount();
1605       }
1606 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 &)){
1607           self->Connect( func );
1608       }
1609 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 &)){
1610           self->Disconnect( func );
1611       }
1612 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){
1613           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1614 /*@SWIG@*/ self->Emit( arg );
1615       }
1616 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1617          return self->Empty();
1618       }
1619 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){
1620         return self->GetConnectionCount();
1621       }
1622 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)){
1623         self->Connect( func );
1624       }
1625 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)){
1626         self->Disconnect( func );
1627       }
1628 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){
1629         return self->Emit( arg1, arg2 );
1630       }
1631 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1632          return self->Empty();
1633       }
1634 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){
1635         return self->GetConnectionCount();
1636       }
1637 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)){
1638         self->Connect( func );
1639       }
1640 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)){
1641         self->Disconnect( func );
1642       }
1643 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){
1644         return self->Emit( arg1, arg2 );
1645       }
1646
1647
1648 /* ---------------------------------------------------
1649  * C++ director class methods
1650  * --------------------------------------------------- */
1651
1652 #include "dali_wrap.h"
1653
1654 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1655   swig_init_callbacks();
1656 }
1657
1658 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1659
1660 }
1661
1662
1663 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1664   int jdepth  ;
1665
1666   if (!swig_callbackOnStageConnection) {
1667     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1668     return;
1669   } else {
1670     jdepth = depth;
1671     swig_callbackOnStageConnection(jdepth);
1672   }
1673 }
1674
1675 void SwigDirector_ViewImpl::OnStageDisconnection() {
1676   if (!swig_callbackOnStageDisconnection) {
1677     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1678     return;
1679   } else {
1680     swig_callbackOnStageDisconnection();
1681   }
1682 }
1683
1684 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1685   void * jchild = 0 ;
1686
1687   if (!swig_callbackOnChildAdd) {
1688     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1689     return;
1690   } else {
1691     jchild = (Dali::Actor *) &child;
1692     swig_callbackOnChildAdd(jchild);
1693   }
1694 }
1695
1696 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1697   void * jchild = 0 ;
1698
1699   if (!swig_callbackOnChildRemove) {
1700     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1701     return;
1702   } else {
1703     jchild = (Dali::Actor *) &child;
1704     swig_callbackOnChildRemove(jchild);
1705   }
1706 }
1707
1708 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1709   int jindex  ;
1710   void * jpropertyValue  ;
1711
1712   if (!swig_callbackOnPropertySet) {
1713     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1714     return;
1715   } else {
1716     jindex = index;
1717     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1718     swig_callbackOnPropertySet(jindex, jpropertyValue);
1719   }
1720 }
1721
1722 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1723   void * jtargetSize = 0 ;
1724
1725   if (!swig_callbackOnSizeSet) {
1726     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1727     return;
1728   } else {
1729     jtargetSize = (Dali::Vector3 *) &targetSize;
1730     swig_callbackOnSizeSet(jtargetSize);
1731   }
1732 }
1733
1734 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1735   void * janimation = 0 ;
1736   void * jtargetSize = 0 ;
1737
1738   if (!swig_callbackOnSizeAnimation) {
1739     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1740     return;
1741   } else {
1742     janimation = (Dali::Animation *) &animation;
1743     jtargetSize = (Dali::Vector3 *) &targetSize;
1744     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1745   }
1746 }
1747
1748 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1749   bool c_result = SwigValueInit< bool >() ;
1750   unsigned int jresult = 0 ;
1751   void * jarg0 = 0 ;
1752
1753   if (!swig_callbackOnTouchEvent) {
1754     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1755   } else {
1756     jarg0 = (Dali::TouchEvent *) &event;
1757     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1758     c_result = jresult ? true : false;
1759   }
1760   return c_result;
1761 }
1762
1763 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1764   bool c_result = SwigValueInit< bool >() ;
1765   unsigned int jresult = 0 ;
1766   void * jarg0 = 0 ;
1767
1768   if (!swig_callbackOnHoverEvent) {
1769     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1770   } else {
1771     jarg0 = (Dali::HoverEvent *) &event;
1772     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1773     c_result = jresult ? true : false;
1774   }
1775   return c_result;
1776 }
1777
1778 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1779   bool c_result = SwigValueInit< bool >() ;
1780   unsigned int jresult = 0 ;
1781   void * jarg0 = 0 ;
1782
1783   if (!swig_callbackOnKeyEvent) {
1784     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1785   } else {
1786     jarg0 = (Dali::KeyEvent *) &event;
1787     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1788     c_result = jresult ? true : false;
1789   }
1790   return c_result;
1791 }
1792
1793 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1794   bool c_result = SwigValueInit< bool >() ;
1795   unsigned int jresult = 0 ;
1796   void * jarg0 = 0 ;
1797
1798   if (!swig_callbackOnWheelEvent) {
1799     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1800   } else {
1801     jarg0 = (Dali::WheelEvent *) &event;
1802     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1803     c_result = jresult ? true : false;
1804   }
1805   return c_result;
1806 }
1807
1808 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1809   void * jsize = 0 ;
1810   void * jcontainer = 0 ;
1811
1812   if (!swig_callbackOnRelayout) {
1813     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1814     return;
1815   } else {
1816     jsize = (Dali::Vector2 *) &size;
1817     jcontainer = (Dali::RelayoutContainer *) &container;
1818     swig_callbackOnRelayout(jsize, jcontainer);
1819   }
1820 }
1821
1822 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1823   int jpolicy  ;
1824   int jdimension  ;
1825
1826   if (!swig_callbackOnSetResizePolicy) {
1827     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1828     return;
1829   } else {
1830     jpolicy = (int)policy;
1831     jdimension = (int)dimension;
1832     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1833   }
1834 }
1835
1836 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1837   Dali::Vector3 c_result ;
1838   void * jresult = 0 ;
1839
1840   if (!swig_callbackGetNaturalSize) {
1841     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1842   } else {
1843     jresult = (void *) swig_callbackGetNaturalSize();
1844     if (!jresult) {
1845       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1846       return c_result;
1847     }
1848     c_result = *(Dali::Vector3 *)jresult;
1849   }
1850   return c_result;
1851 }
1852
1853 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1854   float c_result = SwigValueInit< float >() ;
1855   float jresult = 0 ;
1856   void * jchild = 0 ;
1857   int jdimension  ;
1858
1859   if (!swig_callbackCalculateChildSize) {
1860     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1861   } else {
1862     jchild = (Dali::Actor *) &child;
1863     jdimension = (int)dimension;
1864     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1865     c_result = (float)jresult;
1866   }
1867   return c_result;
1868 }
1869
1870 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1871   float c_result = SwigValueInit< float >() ;
1872   float jresult = 0 ;
1873   float jwidth  ;
1874
1875   if (!swig_callbackGetHeightForWidth) {
1876     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1877   } else {
1878     jwidth = width;
1879     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1880     c_result = (float)jresult;
1881   }
1882   return c_result;
1883 }
1884
1885 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1886   float c_result = SwigValueInit< float >() ;
1887   float jresult = 0 ;
1888   float jheight  ;
1889
1890   if (!swig_callbackGetWidthForHeight) {
1891     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1892   } else {
1893     jheight = height;
1894     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1895     c_result = (float)jresult;
1896   }
1897   return c_result;
1898 }
1899
1900 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1901   bool c_result = SwigValueInit< bool >() ;
1902   unsigned int jresult = 0 ;
1903   int jdimension  ;
1904
1905   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1906     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1907   } else {
1908     jdimension = (int)dimension;
1909     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1910     c_result = jresult ? true : false;
1911   }
1912   return c_result;
1913 }
1914
1915 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1916   int jdimension  ;
1917
1918   if (!swig_callbackOnCalculateRelayoutSize) {
1919     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1920     return;
1921   } else {
1922     jdimension = (int)dimension;
1923     swig_callbackOnCalculateRelayoutSize(jdimension);
1924   }
1925 }
1926
1927 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1928   float jsize  ;
1929   int jdimension  ;
1930
1931   if (!swig_callbackOnLayoutNegotiated) {
1932     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1933     return;
1934   } else {
1935     jsize = size;
1936     jdimension = (int)dimension;
1937     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1938   }
1939 }
1940
1941 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1942   return Dali::CustomActorImpl::GetExtension();
1943 }
1944
1945 void SwigDirector_ViewImpl::OnInitialize() {
1946   if (!swig_callbackOnInitialize) {
1947     Dali::Toolkit::Internal::Control::OnInitialize();
1948     return;
1949   } else {
1950     swig_callbackOnInitialize();
1951   }
1952 }
1953
1954 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1955   void * jchild = 0 ;
1956
1957   if (!swig_callbackOnControlChildAdd) {
1958     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1959     return;
1960   } else {
1961     jchild = (Dali::Actor *) &child;
1962     swig_callbackOnControlChildAdd(jchild);
1963   }
1964 }
1965
1966 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1967   void * jchild = 0 ;
1968
1969   if (!swig_callbackOnControlChildRemove) {
1970     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1971     return;
1972   } else {
1973     jchild = (Dali::Actor *) &child;
1974     swig_callbackOnControlChildRemove(jchild);
1975   }
1976 }
1977
1978 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1979   void * jstyleManager  ;
1980   int jchange  ;
1981
1982   if (!swig_callbackOnStyleChange) {
1983     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1984     return;
1985   } else {
1986     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1987     jchange = (int)change;
1988     swig_callbackOnStyleChange(jstyleManager, jchange);
1989   }
1990 }
1991
1992 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1993   bool c_result = SwigValueInit< bool >() ;
1994   unsigned int jresult = 0 ;
1995
1996   if (!swig_callbackOnAccessibilityActivated) {
1997     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1998   } else {
1999     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2000     c_result = jresult ? true : false;
2001   }
2002   return c_result;
2003 }
2004
2005 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2006   bool c_result = SwigValueInit< bool >() ;
2007   unsigned int jresult = 0 ;
2008   void * jgesture  ;
2009
2010   if (!swig_callbackOnAccessibilityPan) {
2011     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2012   } else {
2013     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2014     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2015     c_result = jresult ? true : false;
2016   }
2017   return c_result;
2018 }
2019
2020 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2021   bool c_result = SwigValueInit< bool >() ;
2022   unsigned int jresult = 0 ;
2023   void * jtouchEvent = 0 ;
2024
2025   if (!swig_callbackOnAccessibilityTouch) {
2026     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2027   } else {
2028     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2029     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2030     c_result = jresult ? true : false;
2031   }
2032   return c_result;
2033 }
2034
2035 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2036   bool c_result = SwigValueInit< bool >() ;
2037   unsigned int jresult = 0 ;
2038   unsigned int jisIncrease  ;
2039
2040   if (!swig_callbackOnAccessibilityValueChange) {
2041     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2042   } else {
2043     jisIncrease = isIncrease;
2044     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2045     c_result = jresult ? true : false;
2046   }
2047   return c_result;
2048 }
2049
2050 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2051   bool c_result = SwigValueInit< bool >() ;
2052   unsigned int jresult = 0 ;
2053
2054   if (!swig_callbackOnAccessibilityZoom) {
2055     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2056   } else {
2057     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2058     c_result = jresult ? true : false;
2059   }
2060   return c_result;
2061 }
2062
2063 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2064   if (!swig_callbackOnKeyInputFocusGained) {
2065     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2066     return;
2067   } else {
2068     swig_callbackOnKeyInputFocusGained();
2069   }
2070 }
2071
2072 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2073   if (!swig_callbackOnKeyInputFocusLost) {
2074     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2075     return;
2076   } else {
2077     swig_callbackOnKeyInputFocusLost();
2078   }
2079 }
2080
2081 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2082   Dali::Actor c_result ;
2083   void * jresult = 0 ;
2084   void * jcurrentFocusedActor  ;
2085   int jdirection  ;
2086   unsigned int jloopEnabled  ;
2087
2088   if (!swig_callbackGetNextKeyboardFocusableActor) {
2089     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2090   } else {
2091     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2092     jdirection = (int)direction;
2093     jloopEnabled = loopEnabled;
2094     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2095     if (!jresult) {
2096       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2097       return c_result;
2098     }
2099     c_result = *(Dali::Actor *)jresult;
2100   }
2101   return c_result;
2102 }
2103
2104 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2105   void * jcommitedFocusableActor  ;
2106
2107   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2108     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2109     return;
2110   } else {
2111     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2112     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2113   }
2114 }
2115
2116 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2117   bool c_result = SwigValueInit< bool >() ;
2118   unsigned int jresult = 0 ;
2119
2120   if (!swig_callbackOnKeyboardEnter) {
2121     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2122   } else {
2123     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2124     c_result = jresult ? true : false;
2125   }
2126   return c_result;
2127 }
2128
2129 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2130   void * jpinch = 0 ;
2131
2132   if (!swig_callbackOnPinch) {
2133     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2134     return;
2135   } else {
2136     jpinch = (Dali::PinchGesture *) &pinch;
2137     swig_callbackOnPinch(jpinch);
2138   }
2139 }
2140
2141 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2142   void * jpan = 0 ;
2143
2144   if (!swig_callbackOnPan) {
2145     Dali::Toolkit::Internal::Control::OnPan(pan);
2146     return;
2147   } else {
2148     jpan = (Dali::PanGesture *) &pan;
2149     swig_callbackOnPan(jpan);
2150   }
2151 }
2152
2153 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2154   void * jtap = 0 ;
2155
2156   if (!swig_callbackOnTap) {
2157     Dali::Toolkit::Internal::Control::OnTap(tap);
2158     return;
2159   } else {
2160     jtap = (Dali::TapGesture *) &tap;
2161     swig_callbackOnTap(jtap);
2162   }
2163 }
2164
2165 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2166   void * jlongPress = 0 ;
2167
2168   if (!swig_callbackOnLongPress) {
2169     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2170     return;
2171   } else {
2172     jlongPress = (Dali::LongPressGesture *) &longPress;
2173     swig_callbackOnLongPress(jlongPress);
2174   }
2175 }
2176
2177 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2178   void * jslotObserver = 0 ;
2179   void * jcallback = 0 ;
2180
2181   if (!swig_callbackSignalConnected) {
2182     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2183     return;
2184   } else {
2185     jslotObserver = (void *) slotObserver;
2186     jcallback = (void *) callback;
2187     swig_callbackSignalConnected(jslotObserver, jcallback);
2188   }
2189 }
2190
2191 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2192   void * jslotObserver = 0 ;
2193   void * jcallback = 0 ;
2194
2195   if (!swig_callbackSignalDisconnected) {
2196     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2197     return;
2198   } else {
2199     jslotObserver = (void *) slotObserver;
2200     jcallback = (void *) callback;
2201     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2202   }
2203 }
2204
2205 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2206   return Dali::Toolkit::Internal::Control::GetControlExtension();
2207 }
2208
2209 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) {
2210   swig_callbackOnStageConnection = callbackOnStageConnection;
2211   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2212   swig_callbackOnChildAdd = callbackOnChildAdd;
2213   swig_callbackOnChildRemove = callbackOnChildRemove;
2214   swig_callbackOnPropertySet = callbackOnPropertySet;
2215   swig_callbackOnSizeSet = callbackOnSizeSet;
2216   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2217   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2218   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2219   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2220   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2221   swig_callbackOnRelayout = callbackOnRelayout;
2222   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2223   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2224   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2225   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2226   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2227   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2228   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2229   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2230   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2231   swig_callbackOnInitialize = callbackOnInitialize;
2232   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2233   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2234   swig_callbackOnStyleChange = callbackOnStyleChange;
2235   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2236   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2237   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2238   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2239   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2240   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2241   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2242   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2243   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2244   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2245   swig_callbackOnPinch = callbackOnPinch;
2246   swig_callbackOnPan = callbackOnPan;
2247   swig_callbackOnTap = callbackOnTap;
2248   swig_callbackOnLongPress = callbackOnLongPress;
2249   swig_callbackSignalConnected = callbackSignalConnected;
2250   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2251 }
2252
2253 void SwigDirector_ViewImpl::swig_init_callbacks() {
2254   swig_callbackOnStageConnection = 0;
2255   swig_callbackOnStageDisconnection = 0;
2256   swig_callbackOnChildAdd = 0;
2257   swig_callbackOnChildRemove = 0;
2258   swig_callbackOnPropertySet = 0;
2259   swig_callbackOnSizeSet = 0;
2260   swig_callbackOnSizeAnimation = 0;
2261   swig_callbackOnTouchEvent = 0;
2262   swig_callbackOnHoverEvent = 0;
2263   swig_callbackOnKeyEvent = 0;
2264   swig_callbackOnWheelEvent = 0;
2265   swig_callbackOnRelayout = 0;
2266   swig_callbackOnSetResizePolicy = 0;
2267   swig_callbackGetNaturalSize = 0;
2268   swig_callbackCalculateChildSize = 0;
2269   swig_callbackGetHeightForWidth = 0;
2270   swig_callbackGetWidthForHeight = 0;
2271   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2272   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2273   swig_callbackOnCalculateRelayoutSize = 0;
2274   swig_callbackOnLayoutNegotiated = 0;
2275   swig_callbackOnInitialize = 0;
2276   swig_callbackOnControlChildAdd = 0;
2277   swig_callbackOnControlChildRemove = 0;
2278   swig_callbackOnStyleChange = 0;
2279   swig_callbackOnAccessibilityActivated = 0;
2280   swig_callbackOnAccessibilityPan = 0;
2281   swig_callbackOnAccessibilityTouch = 0;
2282   swig_callbackOnAccessibilityValueChange = 0;
2283   swig_callbackOnAccessibilityZoom = 0;
2284   swig_callbackOnKeyInputFocusGained = 0;
2285   swig_callbackOnKeyInputFocusLost = 0;
2286   swig_callbackGetNextKeyboardFocusableActor = 0;
2287   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2288   swig_callbackOnKeyboardEnter = 0;
2289   swig_callbackOnPinch = 0;
2290   swig_callbackOnPan = 0;
2291   swig_callbackOnTap = 0;
2292   swig_callbackOnLongPress = 0;
2293   swig_callbackSignalConnected = 0;
2294   swig_callbackSignalDisconnected = 0;
2295 }
2296
2297
2298 #ifdef __cplusplus
2299 extern "C" {
2300 #endif
2301
2302 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_floatp() {
2303   void * jresult ;
2304   floatp *result = 0 ;
2305
2306   {
2307     try {
2308       result = (floatp *)new_floatp();
2309     } catch (std::out_of_range& e) {
2310       {
2311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2312       };
2313     } catch (std::exception& e) {
2314       {
2315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2316       };
2317     } catch (...) {
2318       {
2319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2320       };
2321     }
2322   }
2323   jresult = (void *)result;
2324   return jresult;
2325 }
2326
2327
2328 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_floatp(void * jarg1) {
2329   floatp *arg1 = (floatp *) 0 ;
2330
2331   arg1 = (floatp *)jarg1;
2332   {
2333     try {
2334       delete_floatp(arg1);
2335     } catch (std::out_of_range& e) {
2336       {
2337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2338       };
2339     } catch (std::exception& e) {
2340       {
2341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2342       };
2343     } catch (...) {
2344       {
2345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2346       };
2347     }
2348   }
2349 }
2350
2351
2352 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_floatp_assign(void * jarg1, float jarg2) {
2353   floatp *arg1 = (floatp *) 0 ;
2354   float arg2 ;
2355
2356   arg1 = (floatp *)jarg1;
2357   arg2 = (float)jarg2;
2358   {
2359     try {
2360       floatp_assign(arg1,arg2);
2361     } catch (std::out_of_range& e) {
2362       {
2363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2364       };
2365     } catch (std::exception& e) {
2366       {
2367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2368       };
2369     } catch (...) {
2370       {
2371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2372       };
2373     }
2374   }
2375 }
2376
2377
2378 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_floatp_value(void * jarg1) {
2379   float jresult ;
2380   floatp *arg1 = (floatp *) 0 ;
2381   float result;
2382
2383   arg1 = (floatp *)jarg1;
2384   {
2385     try {
2386       result = (float)floatp_value(arg1);
2387     } catch (std::out_of_range& e) {
2388       {
2389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2390       };
2391     } catch (std::exception& e) {
2392       {
2393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2394       };
2395     } catch (...) {
2396       {
2397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2398       };
2399     }
2400   }
2401   jresult = result;
2402   return jresult;
2403 }
2404
2405
2406 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_floatp_cast(void * jarg1) {
2407   void * jresult ;
2408   floatp *arg1 = (floatp *) 0 ;
2409   float *result = 0 ;
2410
2411   arg1 = (floatp *)jarg1;
2412   {
2413     try {
2414       result = (float *)floatp_cast(arg1);
2415     } catch (std::out_of_range& e) {
2416       {
2417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2418       };
2419     } catch (std::exception& e) {
2420       {
2421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2422       };
2423     } catch (...) {
2424       {
2425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2426       };
2427     }
2428   }
2429   jresult = (void *)result;
2430   return jresult;
2431 }
2432
2433
2434 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_floatp_frompointer(void * jarg1) {
2435   void * jresult ;
2436   float *arg1 = (float *) 0 ;
2437   floatp *result = 0 ;
2438
2439   arg1 = (float *)jarg1;
2440   {
2441     try {
2442       result = (floatp *)floatp_frompointer(arg1);
2443     } catch (std::out_of_range& e) {
2444       {
2445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2446       };
2447     } catch (std::exception& e) {
2448       {
2449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2450       };
2451     } catch (...) {
2452       {
2453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2454       };
2455     }
2456   }
2457   jresult = (void *)result;
2458   return jresult;
2459 }
2460
2461
2462 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_intp() {
2463   void * jresult ;
2464   intp *result = 0 ;
2465
2466   {
2467     try {
2468       result = (intp *)new_intp();
2469     } catch (std::out_of_range& e) {
2470       {
2471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2472       };
2473     } catch (std::exception& e) {
2474       {
2475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2476       };
2477     } catch (...) {
2478       {
2479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2480       };
2481     }
2482   }
2483   jresult = (void *)result;
2484   return jresult;
2485 }
2486
2487
2488 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_intp(void * jarg1) {
2489   intp *arg1 = (intp *) 0 ;
2490
2491   arg1 = (intp *)jarg1;
2492   {
2493     try {
2494       delete_intp(arg1);
2495     } catch (std::out_of_range& e) {
2496       {
2497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2498       };
2499     } catch (std::exception& e) {
2500       {
2501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2502       };
2503     } catch (...) {
2504       {
2505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2506       };
2507     }
2508   }
2509 }
2510
2511
2512 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_intp_assign(void * jarg1, int jarg2) {
2513   intp *arg1 = (intp *) 0 ;
2514   int arg2 ;
2515
2516   arg1 = (intp *)jarg1;
2517   arg2 = (int)jarg2;
2518   {
2519     try {
2520       intp_assign(arg1,arg2);
2521     } catch (std::out_of_range& e) {
2522       {
2523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2524       };
2525     } catch (std::exception& e) {
2526       {
2527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2528       };
2529     } catch (...) {
2530       {
2531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2532       };
2533     }
2534   }
2535 }
2536
2537
2538 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_intp_value(void * jarg1) {
2539   int jresult ;
2540   intp *arg1 = (intp *) 0 ;
2541   int result;
2542
2543   arg1 = (intp *)jarg1;
2544   {
2545     try {
2546       result = (int)intp_value(arg1);
2547     } catch (std::out_of_range& e) {
2548       {
2549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2550       };
2551     } catch (std::exception& e) {
2552       {
2553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2554       };
2555     } catch (...) {
2556       {
2557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2558       };
2559     }
2560   }
2561   jresult = result;
2562   return jresult;
2563 }
2564
2565
2566 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_intp_cast(void * jarg1) {
2567   void * jresult ;
2568   intp *arg1 = (intp *) 0 ;
2569   int *result = 0 ;
2570
2571   arg1 = (intp *)jarg1;
2572   {
2573     try {
2574       result = (int *)intp_cast(arg1);
2575     } catch (std::out_of_range& e) {
2576       {
2577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2578       };
2579     } catch (std::exception& e) {
2580       {
2581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2582       };
2583     } catch (...) {
2584       {
2585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2586       };
2587     }
2588   }
2589   jresult = (void *)result;
2590   return jresult;
2591 }
2592
2593
2594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_intp_frompointer(void * jarg1) {
2595   void * jresult ;
2596   int *arg1 = (int *) 0 ;
2597   intp *result = 0 ;
2598
2599   arg1 = (int *)jarg1;
2600   {
2601     try {
2602       result = (intp *)intp_frompointer(arg1);
2603     } catch (std::out_of_range& e) {
2604       {
2605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (std::exception& e) {
2608       {
2609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_doublep() {
2623   void * jresult ;
2624   doublep *result = 0 ;
2625
2626   {
2627     try {
2628       result = (doublep *)new_doublep();
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2636       };
2637     } catch (...) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2640       };
2641     }
2642   }
2643   jresult = (void *)result;
2644   return jresult;
2645 }
2646
2647
2648 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_doublep(void * jarg1) {
2649   doublep *arg1 = (doublep *) 0 ;
2650
2651   arg1 = (doublep *)jarg1;
2652   {
2653     try {
2654       delete_doublep(arg1);
2655     } catch (std::out_of_range& e) {
2656       {
2657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2658       };
2659     } catch (std::exception& e) {
2660       {
2661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2662       };
2663     } catch (...) {
2664       {
2665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2666       };
2667     }
2668   }
2669 }
2670
2671
2672 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_doublep_assign(void * jarg1, double jarg2) {
2673   doublep *arg1 = (doublep *) 0 ;
2674   double arg2 ;
2675
2676   arg1 = (doublep *)jarg1;
2677   arg2 = (double)jarg2;
2678   {
2679     try {
2680       doublep_assign(arg1,arg2);
2681     } catch (std::out_of_range& e) {
2682       {
2683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2684       };
2685     } catch (std::exception& e) {
2686       {
2687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2688       };
2689     } catch (...) {
2690       {
2691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2692       };
2693     }
2694   }
2695 }
2696
2697
2698 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_doublep_value(void * jarg1) {
2699   double jresult ;
2700   doublep *arg1 = (doublep *) 0 ;
2701   double result;
2702
2703   arg1 = (doublep *)jarg1;
2704   {
2705     try {
2706       result = (double)doublep_value(arg1);
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2714       };
2715     } catch (...) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2718       };
2719     }
2720   }
2721   jresult = result;
2722   return jresult;
2723 }
2724
2725
2726 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_doublep_cast(void * jarg1) {
2727   void * jresult ;
2728   doublep *arg1 = (doublep *) 0 ;
2729   double *result = 0 ;
2730
2731   arg1 = (doublep *)jarg1;
2732   {
2733     try {
2734       result = (double *)doublep_cast(arg1);
2735     } catch (std::out_of_range& e) {
2736       {
2737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2738       };
2739     } catch (std::exception& e) {
2740       {
2741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2742       };
2743     } catch (...) {
2744       {
2745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2746       };
2747     }
2748   }
2749   jresult = (void *)result;
2750   return jresult;
2751 }
2752
2753
2754 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_doublep_frompointer(void * jarg1) {
2755   void * jresult ;
2756   double *arg1 = (double *) 0 ;
2757   doublep *result = 0 ;
2758
2759   arg1 = (double *)jarg1;
2760   {
2761     try {
2762       result = (doublep *)doublep_frompointer(arg1);
2763     } catch (std::out_of_range& e) {
2764       {
2765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2766       };
2767     } catch (std::exception& e) {
2768       {
2769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2770       };
2771     } catch (...) {
2772       {
2773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2774       };
2775     }
2776   }
2777   jresult = (void *)result;
2778   return jresult;
2779 }
2780
2781
2782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_uintp() {
2783   void * jresult ;
2784   uintp *result = 0 ;
2785
2786   {
2787     try {
2788       result = (uintp *)new_uintp();
2789     } catch (std::out_of_range& e) {
2790       {
2791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (std::exception& e) {
2794       {
2795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2800       };
2801     }
2802   }
2803   jresult = (void *)result;
2804   return jresult;
2805 }
2806
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_uintp(void * jarg1) {
2809   uintp *arg1 = (uintp *) 0 ;
2810
2811   arg1 = (uintp *)jarg1;
2812   {
2813     try {
2814       delete_uintp(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2822       };
2823     } catch (...) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2826       };
2827     }
2828   }
2829 }
2830
2831
2832 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_uintp_assign(void * jarg1, unsigned int jarg2) {
2833   uintp *arg1 = (uintp *) 0 ;
2834   unsigned int arg2 ;
2835
2836   arg1 = (uintp *)jarg1;
2837   arg2 = (unsigned int)jarg2;
2838   {
2839     try {
2840       uintp_assign(arg1,arg2);
2841     } catch (std::out_of_range& e) {
2842       {
2843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2844       };
2845     } catch (std::exception& e) {
2846       {
2847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2848       };
2849     } catch (...) {
2850       {
2851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2852       };
2853     }
2854   }
2855 }
2856
2857
2858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_uintp_value(void * jarg1) {
2859   unsigned int jresult ;
2860   uintp *arg1 = (uintp *) 0 ;
2861   unsigned int result;
2862
2863   arg1 = (uintp *)jarg1;
2864   {
2865     try {
2866       result = (unsigned int)uintp_value(arg1);
2867     } catch (std::out_of_range& e) {
2868       {
2869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2870       };
2871     } catch (std::exception& e) {
2872       {
2873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2874       };
2875     } catch (...) {
2876       {
2877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2878       };
2879     }
2880   }
2881   jresult = result;
2882   return jresult;
2883 }
2884
2885
2886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_uintp_cast(void * jarg1) {
2887   void * jresult ;
2888   uintp *arg1 = (uintp *) 0 ;
2889   unsigned int *result = 0 ;
2890
2891   arg1 = (uintp *)jarg1;
2892   {
2893     try {
2894       result = (unsigned int *)uintp_cast(arg1);
2895     } catch (std::out_of_range& e) {
2896       {
2897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2898       };
2899     } catch (std::exception& e) {
2900       {
2901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2902       };
2903     } catch (...) {
2904       {
2905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2906       };
2907     }
2908   }
2909   jresult = (void *)result;
2910   return jresult;
2911 }
2912
2913
2914 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_uintp_frompointer(void * jarg1) {
2915   void * jresult ;
2916   unsigned int *arg1 = (unsigned int *) 0 ;
2917   uintp *result = 0 ;
2918
2919   arg1 = (unsigned int *)jarg1;
2920   {
2921     try {
2922       result = (uintp *)uintp_frompointer(arg1);
2923     } catch (std::out_of_range& e) {
2924       {
2925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2926       };
2927     } catch (std::exception& e) {
2928       {
2929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2930       };
2931     } catch (...) {
2932       {
2933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2934       };
2935     }
2936   }
2937   jresult = (void *)result;
2938   return jresult;
2939 }
2940
2941
2942 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ushortp() {
2943   void * jresult ;
2944   ushortp *result = 0 ;
2945
2946   {
2947     try {
2948       result = (ushortp *)new_ushortp();
2949     } catch (std::out_of_range& e) {
2950       {
2951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2952       };
2953     } catch (std::exception& e) {
2954       {
2955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2956       };
2957     } catch (...) {
2958       {
2959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2960       };
2961     }
2962   }
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ushortp(void * jarg1) {
2969   ushortp *arg1 = (ushortp *) 0 ;
2970
2971   arg1 = (ushortp *)jarg1;
2972   {
2973     try {
2974       delete_ushortp(arg1);
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2982       };
2983     } catch (...) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2986       };
2987     }
2988   }
2989 }
2990
2991
2992 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ushortp_assign(void * jarg1, unsigned short jarg2) {
2993   ushortp *arg1 = (ushortp *) 0 ;
2994   unsigned short arg2 ;
2995
2996   arg1 = (ushortp *)jarg1;
2997   arg2 = (unsigned short)jarg2;
2998   {
2999     try {
3000       ushortp_assign(arg1,arg2);
3001     } catch (std::out_of_range& e) {
3002       {
3003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3004       };
3005     } catch (std::exception& e) {
3006       {
3007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3008       };
3009     } catch (...) {
3010       {
3011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3012       };
3013     }
3014   }
3015 }
3016
3017
3018 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_ushortp_value(void * jarg1) {
3019   unsigned short jresult ;
3020   ushortp *arg1 = (ushortp *) 0 ;
3021   unsigned short result;
3022
3023   arg1 = (ushortp *)jarg1;
3024   {
3025     try {
3026       result = (unsigned short)ushortp_value(arg1);
3027     } catch (std::out_of_range& e) {
3028       {
3029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3030       };
3031     } catch (std::exception& e) {
3032       {
3033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3038       };
3039     }
3040   }
3041   jresult = result;
3042   return jresult;
3043 }
3044
3045
3046 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ushortp_cast(void * jarg1) {
3047   void * jresult ;
3048   ushortp *arg1 = (ushortp *) 0 ;
3049   unsigned short *result = 0 ;
3050
3051   arg1 = (ushortp *)jarg1;
3052   {
3053     try {
3054       result = (unsigned short *)ushortp_cast(arg1);
3055     } catch (std::out_of_range& e) {
3056       {
3057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3058       };
3059     } catch (std::exception& e) {
3060       {
3061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3062       };
3063     } catch (...) {
3064       {
3065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3066       };
3067     }
3068   }
3069   jresult = (void *)result;
3070   return jresult;
3071 }
3072
3073
3074 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ushortp_frompointer(void * jarg1) {
3075   void * jresult ;
3076   unsigned short *arg1 = (unsigned short *) 0 ;
3077   ushortp *result = 0 ;
3078
3079   arg1 = (unsigned short *)jarg1;
3080   {
3081     try {
3082       result = (ushortp *)ushortp_frompointer(arg1);
3083     } catch (std::out_of_range& e) {
3084       {
3085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3086       };
3087     } catch (std::exception& e) {
3088       {
3089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3090       };
3091     } catch (...) {
3092       {
3093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3094       };
3095     }
3096   }
3097   jresult = (void *)result;
3098   return jresult;
3099 }
3100
3101
3102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_int_to_uint(int jarg1) {
3103   unsigned int jresult ;
3104   int arg1 ;
3105   unsigned int result;
3106
3107   arg1 = (int)jarg1;
3108   {
3109     try {
3110       result = (unsigned int)int_to_uint(arg1);
3111     } catch (std::out_of_range& e) {
3112       {
3113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3114       };
3115     } catch (std::exception& e) {
3116       {
3117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3118       };
3119     } catch (...) {
3120       {
3121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3122       };
3123     }
3124   }
3125   jresult = result;
3126   return jresult;
3127 }
3128
3129
3130 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RefObject_Reference(void * jarg1) {
3131   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3132
3133   arg1 = (Dali::RefObject *)jarg1;
3134   {
3135     try {
3136       (arg1)->Reference();
3137     } catch (std::out_of_range& e) {
3138       {
3139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3140       };
3141     } catch (std::exception& e) {
3142       {
3143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3144       };
3145     } catch (...) {
3146       {
3147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3148       };
3149     }
3150   }
3151 }
3152
3153
3154 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RefObject_Unreference(void * jarg1) {
3155   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3156
3157   arg1 = (Dali::RefObject *)jarg1;
3158   {
3159     try {
3160       (arg1)->Unreference();
3161     } catch (std::out_of_range& e) {
3162       {
3163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3164       };
3165     } catch (std::exception& e) {
3166       {
3167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3168       };
3169     } catch (...) {
3170       {
3171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3172       };
3173     }
3174   }
3175 }
3176
3177
3178 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RefObject_ReferenceCount(void * jarg1) {
3179   int jresult ;
3180   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3181   int result;
3182
3183   arg1 = (Dali::RefObject *)jarg1;
3184   {
3185     try {
3186       result = (int)(arg1)->ReferenceCount();
3187     } catch (std::out_of_range& e) {
3188       {
3189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3190       };
3191     } catch (std::exception& e) {
3192       {
3193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3194       };
3195     } catch (...) {
3196       {
3197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3198       };
3199     }
3200   }
3201   jresult = result;
3202   return jresult;
3203 }
3204
3205
3206 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any__SWIG_0() {
3207   void * jresult ;
3208   Dali::Any *result = 0 ;
3209
3210   {
3211     try {
3212       result = (Dali::Any *)new Dali::Any();
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (...) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3224       };
3225     }
3226   }
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Any(void * jarg1) {
3233   Dali::Any *arg1 = (Dali::Any *) 0 ;
3234
3235   arg1 = (Dali::Any *)jarg1;
3236   {
3237     try {
3238       delete arg1;
3239     } catch (std::out_of_range& e) {
3240       {
3241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3242       };
3243     } catch (std::exception& e) {
3244       {
3245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3246       };
3247     } catch (...) {
3248       {
3249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3250       };
3251     }
3252   }
3253 }
3254
3255
3256 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AssertAlways(char * jarg1) {
3257   char *arg1 = (char *) 0 ;
3258
3259   arg1 = (char *)jarg1;
3260   {
3261     try {
3262       Dali::Any::AssertAlways((char const *)arg1);
3263     } catch (std::out_of_range& e) {
3264       {
3265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3266       };
3267     } catch (std::exception& e) {
3268       {
3269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3270       };
3271     } catch (...) {
3272       {
3273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3274       };
3275     }
3276   }
3277 }
3278
3279
3280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any__SWIG_2(void * jarg1) {
3281   void * jresult ;
3282   Dali::Any *arg1 = 0 ;
3283   Dali::Any *result = 0 ;
3284
3285   arg1 = (Dali::Any *)jarg1;
3286   if (!arg1) {
3287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3288     return 0;
3289   }
3290   {
3291     try {
3292       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (...) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3304       };
3305     }
3306   }
3307   jresult = (void *)result;
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_Assign(void * jarg1, void * jarg2) {
3313   void * jresult ;
3314   Dali::Any *arg1 = (Dali::Any *) 0 ;
3315   Dali::Any *arg2 = 0 ;
3316   Dali::Any *result = 0 ;
3317
3318   arg1 = (Dali::Any *)jarg1;
3319   arg2 = (Dali::Any *)jarg2;
3320   if (!arg2) {
3321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3322     return 0;
3323   }
3324   {
3325     try {
3326       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3327     } catch (std::out_of_range& e) {
3328       {
3329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3330       };
3331     } catch (std::exception& e) {
3332       {
3333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3334       };
3335     } catch (...) {
3336       {
3337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3338       };
3339     }
3340   }
3341   jresult = (void *)result;
3342   return jresult;
3343 }
3344
3345
3346 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_GetType(void * jarg1) {
3347   void * jresult ;
3348   Dali::Any *arg1 = (Dali::Any *) 0 ;
3349   std::type_info *result = 0 ;
3350
3351   arg1 = (Dali::Any *)jarg1;
3352   {
3353     try {
3354       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (...) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3366       };
3367     }
3368   }
3369   jresult = (void *)result;
3370   return jresult;
3371 }
3372
3373
3374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Any_Empty(void * jarg1) {
3375   unsigned int jresult ;
3376   Dali::Any *arg1 = (Dali::Any *) 0 ;
3377   bool result;
3378
3379   arg1 = (Dali::Any *)jarg1;
3380   {
3381     try {
3382       result = (bool)((Dali::Any const *)arg1)->Empty();
3383     } catch (std::out_of_range& e) {
3384       {
3385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3386       };
3387     } catch (std::exception& e) {
3388       {
3389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3390       };
3391     } catch (...) {
3392       {
3393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3394       };
3395     }
3396   }
3397   jresult = result;
3398   return jresult;
3399 }
3400
3401
3402 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3403   void * jresult ;
3404   std::type_info *arg1 = 0 ;
3405   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3406   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3407   Dali::Any::AnyContainerBase *result = 0 ;
3408
3409   arg1 = (std::type_info *)jarg1;
3410   if (!arg1) {
3411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3412     return 0;
3413   }
3414   arg2 = (Dali::Any::CloneFunc)jarg2;
3415   arg3 = (Dali::Any::DeleteFunc)jarg3;
3416   {
3417     try {
3418       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3426       };
3427     } catch (...) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3430       };
3431     }
3432   }
3433   jresult = (void *)result;
3434   return jresult;
3435 }
3436
3437
3438 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_GetType(void * jarg1) {
3439   void * jresult ;
3440   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3441   std::type_info *result = 0 ;
3442
3443   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3444   {
3445     try {
3446       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3447     } catch (std::out_of_range& e) {
3448       {
3449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3450       };
3451     } catch (std::exception& e) {
3452       {
3453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (...) {
3456       {
3457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3458       };
3459     }
3460   }
3461   jresult = (void *)result;
3462   return jresult;
3463 }
3464
3465
3466 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mType_get(void * jarg1) {
3467   void * jresult ;
3468   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3469   ::std::type_info *result = 0 ;
3470
3471   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3472   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3473   jresult = (void *)result;
3474   return jresult;
3475 }
3476
3477
3478 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3479   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3480   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3481
3482   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3483   arg2 = (Dali::Any::CloneFunc)jarg2;
3484   if (arg1) (arg1)->mCloneFunc = arg2;
3485 }
3486
3487
3488 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3489   void * jresult ;
3490   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3491   Dali::Any::CloneFunc result;
3492
3493   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3494   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3495   jresult = (void *)result;
3496   return jresult;
3497 }
3498
3499
3500 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3501   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3502   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3503
3504   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3505   arg2 = (Dali::Any::DeleteFunc)jarg2;
3506   if (arg1) (arg1)->mDeleteFunc = arg2;
3507 }
3508
3509
3510 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3511   void * jresult ;
3512   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3513   Dali::Any::DeleteFunc result;
3514
3515   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3516   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3517   jresult = (void *)result;
3518   return jresult;
3519 }
3520
3521
3522 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Any_AnyContainerBase(void * jarg1) {
3523   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3524
3525   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3526   {
3527     try {
3528       delete arg1;
3529     } catch (std::out_of_range& e) {
3530       {
3531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3532       };
3533     } catch (std::exception& e) {
3534       {
3535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3536       };
3537     } catch (...) {
3538       {
3539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3540       };
3541     }
3542   }
3543 }
3544
3545
3546 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_mContainer_set(void * jarg1, void * jarg2) {
3547   Dali::Any *arg1 = (Dali::Any *) 0 ;
3548   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3549
3550   arg1 = (Dali::Any *)jarg1;
3551   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3552   if (arg1) (arg1)->mContainer = arg2;
3553 }
3554
3555
3556 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_mContainer_get(void * jarg1) {
3557   void * jresult ;
3558   Dali::Any *arg1 = (Dali::Any *) 0 ;
3559   Dali::Any::AnyContainerBase *result = 0 ;
3560
3561   arg1 = (Dali::Any *)jarg1;
3562   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3563   jresult = (void *)result;
3564   return jresult;
3565 }
3566
3567
3568 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliAssertMessage(char * jarg1, char * jarg2) {
3569   char *arg1 = (char *) 0 ;
3570   char *arg2 = (char *) 0 ;
3571
3572   arg1 = (char *)jarg1;
3573   arg2 = (char *)jarg2;
3574   {
3575     try {
3576       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3584       };
3585     } catch (...) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3588       };
3589     }
3590   }
3591 }
3592
3593
3594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DaliException(char * jarg1, char * jarg2) {
3595   void * jresult ;
3596   char *arg1 = (char *) 0 ;
3597   char *arg2 = (char *) 0 ;
3598   Dali::DaliException *result = 0 ;
3599
3600   arg1 = (char *)jarg1;
3601   arg2 = (char *)jarg2;
3602   {
3603     try {
3604       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3605     } catch (std::out_of_range& e) {
3606       {
3607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3608       };
3609     } catch (std::exception& e) {
3610       {
3611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3612       };
3613     } catch (...) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3616       };
3617     }
3618   }
3619   jresult = (void *)result;
3620   return jresult;
3621 }
3622
3623
3624 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliException_location_set(void * jarg1, char * jarg2) {
3625   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3626   char *arg2 = (char *) 0 ;
3627
3628   arg1 = (Dali::DaliException *)jarg1;
3629   arg2 = (char *)jarg2;
3630   {
3631     if (arg2) {
3632       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3633       strcpy((char *)arg1->location, (const char *)arg2);
3634     } else {
3635       arg1->location = 0;
3636     }
3637   }
3638 }
3639
3640
3641 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DaliException_location_get(void * jarg1) {
3642   char * jresult ;
3643   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3644   char *result = 0 ;
3645
3646   arg1 = (Dali::DaliException *)jarg1;
3647   result = (char *) ((arg1)->location);
3648   jresult = SWIG_csharp_string_callback((const char *)result);
3649   return jresult;
3650 }
3651
3652
3653 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliException_condition_set(void * jarg1, char * jarg2) {
3654   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3655   char *arg2 = (char *) 0 ;
3656
3657   arg1 = (Dali::DaliException *)jarg1;
3658   arg2 = (char *)jarg2;
3659   {
3660     if (arg2) {
3661       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3662       strcpy((char *)arg1->condition, (const char *)arg2);
3663     } else {
3664       arg1->condition = 0;
3665     }
3666   }
3667 }
3668
3669
3670 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DaliException_condition_get(void * jarg1) {
3671   char * jresult ;
3672   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3673   char *result = 0 ;
3674
3675   arg1 = (Dali::DaliException *)jarg1;
3676   result = (char *) ((arg1)->condition);
3677   jresult = SWIG_csharp_string_callback((const char *)result);
3678   return jresult;
3679 }
3680
3681
3682 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DaliException(void * jarg1) {
3683   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3684
3685   arg1 = (Dali::DaliException *)jarg1;
3686   {
3687     try {
3688       delete arg1;
3689     } catch (std::out_of_range& e) {
3690       {
3691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3692       };
3693     } catch (std::exception& e) {
3694       {
3695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3696       };
3697     } catch (...) {
3698       {
3699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3700       };
3701     }
3702   }
3703 }
3704
3705
3706 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_0() {
3707   void * jresult ;
3708   Dali::Vector2 *result = 0 ;
3709
3710   {
3711     try {
3712       result = (Dali::Vector2 *)new Dali::Vector2();
3713     } catch (std::out_of_range& e) {
3714       {
3715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3716       };
3717     } catch (std::exception& e) {
3718       {
3719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3720       };
3721     } catch (...) {
3722       {
3723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3724       };
3725     }
3726   }
3727   jresult = (void *)result;
3728   return jresult;
3729 }
3730
3731
3732 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3733   void * jresult ;
3734   float arg1 ;
3735   float arg2 ;
3736   Dali::Vector2 *result = 0 ;
3737
3738   arg1 = (float)jarg1;
3739   arg2 = (float)jarg2;
3740   {
3741     try {
3742       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3743     } catch (std::out_of_range& e) {
3744       {
3745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3746       };
3747     } catch (std::exception& e) {
3748       {
3749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3750       };
3751     } catch (...) {
3752       {
3753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3754       };
3755     }
3756   }
3757   jresult = (void *)result;
3758   return jresult;
3759 }
3760
3761
3762 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_2(float* jarg1) {
3763   void * jresult ;
3764   float *arg1 = (float *) 0 ;
3765   Dali::Vector2 *result = 0 ;
3766
3767   arg1 = jarg1;
3768   {
3769     try {
3770       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3771     } catch (std::out_of_range& e) {
3772       {
3773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3774       };
3775     } catch (std::exception& e) {
3776       {
3777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3778       };
3779     } catch (...) {
3780       {
3781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3782       };
3783     }
3784   }
3785   jresult = (void *)result;
3786
3787
3788   return jresult;
3789 }
3790
3791
3792 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_3(void * jarg1) {
3793   void * jresult ;
3794   Dali::Vector3 *arg1 = 0 ;
3795   Dali::Vector2 *result = 0 ;
3796
3797   arg1 = (Dali::Vector3 *)jarg1;
3798   if (!arg1) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (...) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3816       };
3817     }
3818   }
3819   jresult = (void *)result;
3820   return jresult;
3821 }
3822
3823
3824 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_4(void * jarg1) {
3825   void * jresult ;
3826   Dali::Vector4 *arg1 = 0 ;
3827   Dali::Vector2 *result = 0 ;
3828
3829   arg1 = (Dali::Vector4 *)jarg1;
3830   if (!arg1) {
3831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3832     return 0;
3833   }
3834   {
3835     try {
3836       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3837     } catch (std::out_of_range& e) {
3838       {
3839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (std::exception& e) {
3842       {
3843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (...) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3848       };
3849     }
3850   }
3851   jresult = (void *)result;
3852   return jresult;
3853 }
3854
3855
3856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_ONE_get() {
3857   void * jresult ;
3858   Dali::Vector2 *result = 0 ;
3859
3860   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3861   jresult = (void *)result;
3862   return jresult;
3863 }
3864
3865
3866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_XAXIS_get() {
3867   void * jresult ;
3868   Dali::Vector2 *result = 0 ;
3869
3870   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3871   jresult = (void *)result;
3872   return jresult;
3873 }
3874
3875
3876 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_YAXIS_get() {
3877   void * jresult ;
3878   Dali::Vector2 *result = 0 ;
3879
3880   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3881   jresult = (void *)result;
3882   return jresult;
3883 }
3884
3885
3886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_NEGATIVE_XAXIS_get() {
3887   void * jresult ;
3888   Dali::Vector2 *result = 0 ;
3889
3890   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3891   jresult = (void *)result;
3892   return jresult;
3893 }
3894
3895
3896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_NEGATIVE_YAXIS_get() {
3897   void * jresult ;
3898   Dali::Vector2 *result = 0 ;
3899
3900   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3901   jresult = (void *)result;
3902   return jresult;
3903 }
3904
3905
3906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_ZERO_get() {
3907   void * jresult ;
3908   Dali::Vector2 *result = 0 ;
3909
3910   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3911   jresult = (void *)result;
3912   return jresult;
3913 }
3914
3915
3916 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3917   void * jresult ;
3918   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3919   float *arg2 = (float *) 0 ;
3920   Dali::Vector2 *result = 0 ;
3921
3922   arg1 = (Dali::Vector2 *)jarg1;
3923   arg2 = jarg2;
3924   {
3925     try {
3926       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3927     } catch (std::out_of_range& e) {
3928       {
3929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3930       };
3931     } catch (std::exception& e) {
3932       {
3933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3934       };
3935     } catch (...) {
3936       {
3937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3938       };
3939     }
3940   }
3941   jresult = (void *)result;
3942
3943
3944   return jresult;
3945 }
3946
3947
3948 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3949   void * jresult ;
3950   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3951   Dali::Vector3 *arg2 = 0 ;
3952   Dali::Vector2 *result = 0 ;
3953
3954   arg1 = (Dali::Vector2 *)jarg1;
3955   arg2 = (Dali::Vector3 *)jarg2;
3956   if (!arg2) {
3957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3958     return 0;
3959   }
3960   {
3961     try {
3962       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3963     } catch (std::out_of_range& e) {
3964       {
3965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3966       };
3967     } catch (std::exception& e) {
3968       {
3969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3970       };
3971     } catch (...) {
3972       {
3973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3974       };
3975     }
3976   }
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3983   void * jresult ;
3984   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3985   Dali::Vector4 *arg2 = 0 ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   arg1 = (Dali::Vector2 *)jarg1;
3989   arg2 = (Dali::Vector4 *)jarg2;
3990   if (!arg2) {
3991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3992     return 0;
3993   }
3994   {
3995     try {
3996       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3997     } catch (std::out_of_range& e) {
3998       {
3999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4000       };
4001     } catch (std::exception& e) {
4002       {
4003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4004       };
4005     } catch (...) {
4006       {
4007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4008       };
4009     }
4010   }
4011   jresult = (void *)result;
4012   return jresult;
4013 }
4014
4015
4016 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Add(void * jarg1, void * jarg2) {
4017   void * jresult ;
4018   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4019   Dali::Vector2 *arg2 = 0 ;
4020   Dali::Vector2 result;
4021
4022   arg1 = (Dali::Vector2 *)jarg1;
4023   arg2 = (Dali::Vector2 *)jarg2;
4024   if (!arg2) {
4025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4026     return 0;
4027   }
4028   {
4029     try {
4030       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4031     } catch (std::out_of_range& e) {
4032       {
4033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4034       };
4035     } catch (std::exception& e) {
4036       {
4037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4038       };
4039     } catch (...) {
4040       {
4041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4042       };
4043     }
4044   }
4045   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4046   return jresult;
4047 }
4048
4049
4050 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_AddAssign(void * jarg1, void * jarg2) {
4051   void * jresult ;
4052   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4053   Dali::Vector2 *arg2 = 0 ;
4054   Dali::Vector2 *result = 0 ;
4055
4056   arg1 = (Dali::Vector2 *)jarg1;
4057   arg2 = (Dali::Vector2 *)jarg2;
4058   if (!arg2) {
4059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4060     return 0;
4061   }
4062   {
4063     try {
4064       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4065     } catch (std::out_of_range& e) {
4066       {
4067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4068       };
4069     } catch (std::exception& e) {
4070       {
4071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4072       };
4073     } catch (...) {
4074       {
4075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4076       };
4077     }
4078   }
4079   jresult = (void *)result;
4080   return jresult;
4081 }
4082
4083
4084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4085   void * jresult ;
4086   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4087   Dali::Vector2 *arg2 = 0 ;
4088   Dali::Vector2 result;
4089
4090   arg1 = (Dali::Vector2 *)jarg1;
4091   arg2 = (Dali::Vector2 *)jarg2;
4092   if (!arg2) {
4093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4094     return 0;
4095   }
4096   {
4097     try {
4098       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4099     } catch (std::out_of_range& e) {
4100       {
4101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4102       };
4103     } catch (std::exception& e) {
4104       {
4105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4106       };
4107     } catch (...) {
4108       {
4109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4110       };
4111     }
4112   }
4113   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4114   return jresult;
4115 }
4116
4117
4118 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4119   void * jresult ;
4120   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4121   Dali::Vector2 *arg2 = 0 ;
4122   Dali::Vector2 *result = 0 ;
4123
4124   arg1 = (Dali::Vector2 *)jarg1;
4125   arg2 = (Dali::Vector2 *)jarg2;
4126   if (!arg2) {
4127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4128     return 0;
4129   }
4130   {
4131     try {
4132       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4133     } catch (std::out_of_range& e) {
4134       {
4135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4136       };
4137     } catch (std::exception& e) {
4138       {
4139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4140       };
4141     } catch (...) {
4142       {
4143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4144       };
4145     }
4146   }
4147   jresult = (void *)result;
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4153   void * jresult ;
4154   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4155   Dali::Vector2 *arg2 = 0 ;
4156   Dali::Vector2 result;
4157
4158   arg1 = (Dali::Vector2 *)jarg1;
4159   arg2 = (Dali::Vector2 *)jarg2;
4160   if (!arg2) {
4161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4162     return 0;
4163   }
4164   {
4165     try {
4166       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4167     } catch (std::out_of_range& e) {
4168       {
4169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4170       };
4171     } catch (std::exception& e) {
4172       {
4173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4174       };
4175     } catch (...) {
4176       {
4177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4178       };
4179     }
4180   }
4181   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4182   return jresult;
4183 }
4184
4185
4186 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4187   void * jresult ;
4188   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4189   float arg2 ;
4190   Dali::Vector2 result;
4191
4192   arg1 = (Dali::Vector2 *)jarg1;
4193   arg2 = (float)jarg2;
4194   {
4195     try {
4196       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4197     } catch (std::out_of_range& e) {
4198       {
4199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4200       };
4201     } catch (std::exception& e) {
4202       {
4203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4204       };
4205     } catch (...) {
4206       {
4207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4208       };
4209     }
4210   }
4211   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4212   return jresult;
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4217   void * jresult ;
4218   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4219   Dali::Vector2 *arg2 = 0 ;
4220   Dali::Vector2 *result = 0 ;
4221
4222   arg1 = (Dali::Vector2 *)jarg1;
4223   arg2 = (Dali::Vector2 *)jarg2;
4224   if (!arg2) {
4225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4226     return 0;
4227   }
4228   {
4229     try {
4230       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (...) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4242       };
4243     }
4244   }
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4251   void * jresult ;
4252   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4253   float arg2 ;
4254   Dali::Vector2 *result = 0 ;
4255
4256   arg1 = (Dali::Vector2 *)jarg1;
4257   arg2 = (float)jarg2;
4258   {
4259     try {
4260       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4261     } catch (std::out_of_range& e) {
4262       {
4263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4264       };
4265     } catch (std::exception& e) {
4266       {
4267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (...) {
4270       {
4271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4272       };
4273     }
4274   }
4275   jresult = (void *)result;
4276   return jresult;
4277 }
4278
4279
4280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4281   void * jresult ;
4282   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4283   Dali::Vector2 *arg2 = 0 ;
4284   Dali::Vector2 result;
4285
4286   arg1 = (Dali::Vector2 *)jarg1;
4287   arg2 = (Dali::Vector2 *)jarg2;
4288   if (!arg2) {
4289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4290     return 0;
4291   }
4292   {
4293     try {
4294       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4295     } catch (std::out_of_range& e) {
4296       {
4297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (std::exception& e) {
4300       {
4301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4310   return jresult;
4311 }
4312
4313
4314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4315   void * jresult ;
4316   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4317   float arg2 ;
4318   Dali::Vector2 result;
4319
4320   arg1 = (Dali::Vector2 *)jarg1;
4321   arg2 = (float)jarg2;
4322   {
4323     try {
4324       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (...) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4336       };
4337     }
4338   }
4339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4340   return jresult;
4341 }
4342
4343
4344 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4345   void * jresult ;
4346   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4347   Dali::Vector2 *arg2 = 0 ;
4348   Dali::Vector2 *result = 0 ;
4349
4350   arg1 = (Dali::Vector2 *)jarg1;
4351   arg2 = (Dali::Vector2 *)jarg2;
4352   if (!arg2) {
4353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4354     return 0;
4355   }
4356   {
4357     try {
4358       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4359     } catch (std::out_of_range& e) {
4360       {
4361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (std::exception& e) {
4364       {
4365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4366       };
4367     } catch (...) {
4368       {
4369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4370       };
4371     }
4372   }
4373   jresult = (void *)result;
4374   return jresult;
4375 }
4376
4377
4378 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4379   void * jresult ;
4380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4381   float arg2 ;
4382   Dali::Vector2 *result = 0 ;
4383
4384   arg1 = (Dali::Vector2 *)jarg1;
4385   arg2 = (float)jarg2;
4386   {
4387     try {
4388       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4389     } catch (std::out_of_range& e) {
4390       {
4391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4392       };
4393     } catch (std::exception& e) {
4394       {
4395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4396       };
4397     } catch (...) {
4398       {
4399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4400       };
4401     }
4402   }
4403   jresult = (void *)result;
4404   return jresult;
4405 }
4406
4407
4408 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Subtract__SWIG_1(void * jarg1) {
4409   void * jresult ;
4410   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4411   Dali::Vector2 result;
4412
4413   arg1 = (Dali::Vector2 *)jarg1;
4414   {
4415     try {
4416       result = ((Dali::Vector2 const *)arg1)->operator -();
4417     } catch (std::out_of_range& e) {
4418       {
4419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4420       };
4421     } catch (std::exception& e) {
4422       {
4423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4424       };
4425     } catch (...) {
4426       {
4427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4428       };
4429     }
4430   }
4431   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector2_EqualTo(void * jarg1, void * jarg2) {
4437   unsigned int jresult ;
4438   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4439   Dali::Vector2 *arg2 = 0 ;
4440   bool result;
4441
4442   arg1 = (Dali::Vector2 *)jarg1;
4443   arg2 = (Dali::Vector2 *)jarg2;
4444   if (!arg2) {
4445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4446     return 0;
4447   }
4448   {
4449     try {
4450       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4451     } catch (std::out_of_range& e) {
4452       {
4453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4454       };
4455     } catch (std::exception& e) {
4456       {
4457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4458       };
4459     } catch (...) {
4460       {
4461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4462       };
4463     }
4464   }
4465   jresult = result;
4466   return jresult;
4467 }
4468
4469
4470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4471   unsigned int jresult ;
4472   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4473   Dali::Vector2 *arg2 = 0 ;
4474   bool result;
4475
4476   arg1 = (Dali::Vector2 *)jarg1;
4477   arg2 = (Dali::Vector2 *)jarg2;
4478   if (!arg2) {
4479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4480     return 0;
4481   }
4482   {
4483     try {
4484       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4485     } catch (std::out_of_range& e) {
4486       {
4487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4488       };
4489     } catch (std::exception& e) {
4490       {
4491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4492       };
4493     } catch (...) {
4494       {
4495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4496       };
4497     }
4498   }
4499   jresult = result;
4500   return jresult;
4501 }
4502
4503
4504 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4505   float jresult ;
4506   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4507   unsigned int arg2 ;
4508   float *result = 0 ;
4509
4510   arg1 = (Dali::Vector2 *)jarg1;
4511   arg2 = (unsigned int)jarg2;
4512   {
4513     try {
4514       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4515     } catch (std::out_of_range& e) {
4516       {
4517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (std::exception& e) {
4520       {
4521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529   jresult = *result;
4530   return jresult;
4531 }
4532
4533
4534 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Length(void * jarg1) {
4535   float jresult ;
4536   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4537   float result;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   {
4541     try {
4542       result = (float)((Dali::Vector2 const *)arg1)->Length();
4543     } catch (std::out_of_range& e) {
4544       {
4545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4546       };
4547     } catch (std::exception& e) {
4548       {
4549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (...) {
4552       {
4553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4554       };
4555     }
4556   }
4557   jresult = result;
4558   return jresult;
4559 }
4560
4561
4562 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_LengthSquared(void * jarg1) {
4563   float jresult ;
4564   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4565   float result;
4566
4567   arg1 = (Dali::Vector2 *)jarg1;
4568   {
4569     try {
4570       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4571     } catch (std::out_of_range& e) {
4572       {
4573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4574       };
4575     } catch (std::exception& e) {
4576       {
4577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4578       };
4579     } catch (...) {
4580       {
4581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4582       };
4583     }
4584   }
4585   jresult = result;
4586   return jresult;
4587 }
4588
4589
4590 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Normalize(void * jarg1) {
4591   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4592
4593   arg1 = (Dali::Vector2 *)jarg1;
4594   {
4595     try {
4596       (arg1)->Normalize();
4597     } catch (std::out_of_range& e) {
4598       {
4599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4600       };
4601     } catch (std::exception& e) {
4602       {
4603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4604       };
4605     } catch (...) {
4606       {
4607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4608       };
4609     }
4610   }
4611 }
4612
4613
4614 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *arg3 = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return ;
4624   }
4625   arg3 = (Dali::Vector2 *)jarg3;
4626   if (!arg3) {
4627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4628     return ;
4629   }
4630   {
4631     try {
4632       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4633     } catch (std::out_of_range& e) {
4634       {
4635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4636       };
4637     } catch (std::exception& e) {
4638       {
4639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4640       };
4641     } catch (...) {
4642       {
4643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4644       };
4645     }
4646   }
4647 }
4648
4649
4650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_AsFloat__SWIG_0(void * jarg1) {
4651   void * jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   float *result = 0 ;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   {
4657     try {
4658       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4659     } catch (std::out_of_range& e) {
4660       {
4661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (std::exception& e) {
4664       {
4665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (...) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4670       };
4671     }
4672   }
4673   jresult = (void *)result;
4674   return jresult;
4675 }
4676
4677
4678 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_X_set(void * jarg1, float jarg2) {
4679   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4680   float arg2 ;
4681
4682   arg1 = (Dali::Vector2 *)jarg1;
4683   arg2 = (float)jarg2;
4684   if (arg1) (arg1)->x = arg2;
4685 }
4686
4687
4688 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_X_get(void * jarg1) {
4689   float jresult ;
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691   float result;
4692
4693   arg1 = (Dali::Vector2 *)jarg1;
4694   result = (float) ((arg1)->x);
4695   jresult = result;
4696   return jresult;
4697 }
4698
4699
4700 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Width_set(void * jarg1, float jarg2) {
4701   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4702   float arg2 ;
4703
4704   arg1 = (Dali::Vector2 *)jarg1;
4705   arg2 = (float)jarg2;
4706   if (arg1) (arg1)->width = arg2;
4707 }
4708
4709
4710 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Width_get(void * jarg1) {
4711   float jresult ;
4712   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4713   float result;
4714
4715   arg1 = (Dali::Vector2 *)jarg1;
4716   result = (float) ((arg1)->width);
4717   jresult = result;
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Y_set(void * jarg1, float jarg2) {
4723   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4724   float arg2 ;
4725
4726   arg1 = (Dali::Vector2 *)jarg1;
4727   arg2 = (float)jarg2;
4728   if (arg1) (arg1)->y = arg2;
4729 }
4730
4731
4732 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Y_get(void * jarg1) {
4733   float jresult ;
4734   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4735   float result;
4736
4737   arg1 = (Dali::Vector2 *)jarg1;
4738   result = (float) ((arg1)->y);
4739   jresult = result;
4740   return jresult;
4741 }
4742
4743
4744 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Height_set(void * jarg1, float jarg2) {
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float arg2 ;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   arg2 = (float)jarg2;
4750   if (arg1) (arg1)->height = arg2;
4751 }
4752
4753
4754 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Height_get(void * jarg1) {
4755   float jresult ;
4756   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4757   float result;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   result = (float) ((arg1)->height);
4761   jresult = result;
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector2(void * jarg1) {
4767   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4768
4769   arg1 = (Dali::Vector2 *)jarg1;
4770   {
4771     try {
4772       delete arg1;
4773     } catch (std::out_of_range& e) {
4774       {
4775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4776       };
4777     } catch (std::exception& e) {
4778       {
4779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4780       };
4781     } catch (...) {
4782       {
4783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4784       };
4785     }
4786   }
4787 }
4788
4789
4790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_0(void * jarg1, void * jarg2) {
4791   void * jresult ;
4792   Dali::Vector2 *arg1 = 0 ;
4793   Dali::Vector2 *arg2 = 0 ;
4794   Dali::Vector2 result;
4795
4796   arg1 = (Dali::Vector2 *)jarg1;
4797   if (!arg1) {
4798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4799     return 0;
4800   }
4801   arg2 = (Dali::Vector2 *)jarg2;
4802   if (!arg2) {
4803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4804     return 0;
4805   }
4806   {
4807     try {
4808       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4809     } catch (std::out_of_range& e) {
4810       {
4811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4812       };
4813     } catch (std::exception& e) {
4814       {
4815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4816       };
4817     } catch (...) {
4818       {
4819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4820       };
4821     }
4822   }
4823   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4824   return jresult;
4825 }
4826
4827
4828 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_0(void * jarg1, void * jarg2) {
4829   void * jresult ;
4830   Dali::Vector2 *arg1 = 0 ;
4831   Dali::Vector2 *arg2 = 0 ;
4832   Dali::Vector2 result;
4833
4834   arg1 = (Dali::Vector2 *)jarg1;
4835   if (!arg1) {
4836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4837     return 0;
4838   }
4839   arg2 = (Dali::Vector2 *)jarg2;
4840   if (!arg2) {
4841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4842     return 0;
4843   }
4844   {
4845     try {
4846       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4847     } catch (std::out_of_range& e) {
4848       {
4849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4850       };
4851     } catch (std::exception& e) {
4852       {
4853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4854       };
4855     } catch (...) {
4856       {
4857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4858       };
4859     }
4860   }
4861   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4862   return jresult;
4863 }
4864
4865
4866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4867   void * jresult ;
4868   Dali::Vector2 *arg1 = 0 ;
4869   float *arg2 = 0 ;
4870   float *arg3 = 0 ;
4871   float temp2 ;
4872   float temp3 ;
4873   Dali::Vector2 result;
4874
4875   arg1 = (Dali::Vector2 *)jarg1;
4876   if (!arg1) {
4877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4878     return 0;
4879   }
4880   temp2 = (float)jarg2;
4881   arg2 = &temp2;
4882   temp3 = (float)jarg3;
4883   arg3 = &temp3;
4884   {
4885     try {
4886       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4887     } catch (std::out_of_range& e) {
4888       {
4889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4890       };
4891     } catch (std::exception& e) {
4892       {
4893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (...) {
4896       {
4897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4898       };
4899     }
4900   }
4901   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4902   return jresult;
4903 }
4904
4905
4906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_0() {
4907   void * jresult ;
4908   Dali::Vector3 *result = 0 ;
4909
4910   {
4911     try {
4912       result = (Dali::Vector3 *)new Dali::Vector3();
4913     } catch (std::out_of_range& e) {
4914       {
4915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4916       };
4917     } catch (std::exception& e) {
4918       {
4919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4920       };
4921     } catch (...) {
4922       {
4923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4924       };
4925     }
4926   }
4927   jresult = (void *)result;
4928   return jresult;
4929 }
4930
4931
4932 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4933   void * jresult ;
4934   float arg1 ;
4935   float arg2 ;
4936   float arg3 ;
4937   Dali::Vector3 *result = 0 ;
4938
4939   arg1 = (float)jarg1;
4940   arg2 = (float)jarg2;
4941   arg3 = (float)jarg3;
4942   {
4943     try {
4944       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4945     } catch (std::out_of_range& e) {
4946       {
4947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4948       };
4949     } catch (std::exception& e) {
4950       {
4951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4952       };
4953     } catch (...) {
4954       {
4955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4956       };
4957     }
4958   }
4959   jresult = (void *)result;
4960   return jresult;
4961 }
4962
4963
4964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_2(float* jarg1) {
4965   void * jresult ;
4966   float *arg1 = (float *) 0 ;
4967   Dali::Vector3 *result = 0 ;
4968
4969   arg1 = jarg1;
4970   {
4971     try {
4972       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4973     } catch (std::out_of_range& e) {
4974       {
4975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4976       };
4977     } catch (std::exception& e) {
4978       {
4979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4980       };
4981     } catch (...) {
4982       {
4983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4984       };
4985     }
4986   }
4987   jresult = (void *)result;
4988
4989
4990   return jresult;
4991 }
4992
4993
4994 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_3(void * jarg1) {
4995   void * jresult ;
4996   Dali::Vector2 *arg1 = 0 ;
4997   Dali::Vector3 *result = 0 ;
4998
4999   arg1 = (Dali::Vector2 *)jarg1;
5000   if (!arg1) {
5001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5002     return 0;
5003   }
5004   {
5005     try {
5006       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5007     } catch (std::out_of_range& e) {
5008       {
5009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5010       };
5011     } catch (std::exception& e) {
5012       {
5013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (...) {
5016       {
5017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5018       };
5019     }
5020   }
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_4(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector4 *arg1 = 0 ;
5029   Dali::Vector3 *result = 0 ;
5030
5031   arg1 = (Dali::Vector4 *)jarg1;
5032   if (!arg1) {
5033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5034     return 0;
5035   }
5036   {
5037     try {
5038       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5039     } catch (std::out_of_range& e) {
5040       {
5041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (std::exception& e) {
5044       {
5045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053   jresult = (void *)result;
5054   return jresult;
5055 }
5056
5057
5058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ONE_get() {
5059   void * jresult ;
5060   Dali::Vector3 *result = 0 ;
5061
5062   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5063   jresult = (void *)result;
5064   return jresult;
5065 }
5066
5067
5068 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_XAXIS_get() {
5069   void * jresult ;
5070   Dali::Vector3 *result = 0 ;
5071
5072   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5073   jresult = (void *)result;
5074   return jresult;
5075 }
5076
5077
5078 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_YAXIS_get() {
5079   void * jresult ;
5080   Dali::Vector3 *result = 0 ;
5081
5082   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5083   jresult = (void *)result;
5084   return jresult;
5085 }
5086
5087
5088 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ZAXIS_get() {
5089   void * jresult ;
5090   Dali::Vector3 *result = 0 ;
5091
5092   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5093   jresult = (void *)result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_XAXIS_get() {
5099   void * jresult ;
5100   Dali::Vector3 *result = 0 ;
5101
5102   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5103   jresult = (void *)result;
5104   return jresult;
5105 }
5106
5107
5108 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_YAXIS_get() {
5109   void * jresult ;
5110   Dali::Vector3 *result = 0 ;
5111
5112   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5113   jresult = (void *)result;
5114   return jresult;
5115 }
5116
5117
5118 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_ZAXIS_get() {
5119   void * jresult ;
5120   Dali::Vector3 *result = 0 ;
5121
5122   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5123   jresult = (void *)result;
5124   return jresult;
5125 }
5126
5127
5128 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ZERO_get() {
5129   void * jresult ;
5130   Dali::Vector3 *result = 0 ;
5131
5132   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5133   jresult = (void *)result;
5134   return jresult;
5135 }
5136
5137
5138 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5139   void * jresult ;
5140   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5141   float *arg2 = (float *) 0 ;
5142   Dali::Vector3 *result = 0 ;
5143
5144   arg1 = (Dali::Vector3 *)jarg1;
5145   arg2 = jarg2;
5146   {
5147     try {
5148       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5149     } catch (std::out_of_range& e) {
5150       {
5151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5152       };
5153     } catch (std::exception& e) {
5154       {
5155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5156       };
5157     } catch (...) {
5158       {
5159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5160       };
5161     }
5162   }
5163   jresult = (void *)result;
5164
5165
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5171   void * jresult ;
5172   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5173   Dali::Vector2 *arg2 = 0 ;
5174   Dali::Vector3 *result = 0 ;
5175
5176   arg1 = (Dali::Vector3 *)jarg1;
5177   arg2 = (Dali::Vector2 *)jarg2;
5178   if (!arg2) {
5179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5180     return 0;
5181   }
5182   {
5183     try {
5184       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5185     } catch (std::out_of_range& e) {
5186       {
5187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (std::exception& e) {
5190       {
5191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199   jresult = (void *)result;
5200   return jresult;
5201 }
5202
5203
5204 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5205   void * jresult ;
5206   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5207   Dali::Vector4 *arg2 = 0 ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   arg1 = (Dali::Vector3 *)jarg1;
5211   arg2 = (Dali::Vector4 *)jarg2;
5212   if (!arg2) {
5213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5214     return 0;
5215   }
5216   {
5217     try {
5218       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5219     } catch (std::out_of_range& e) {
5220       {
5221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (std::exception& e) {
5224       {
5225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5226       };
5227     } catch (...) {
5228       {
5229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5230       };
5231     }
5232   }
5233   jresult = (void *)result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Add(void * jarg1, void * jarg2) {
5239   void * jresult ;
5240   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5241   Dali::Vector3 *arg2 = 0 ;
5242   Dali::Vector3 result;
5243
5244   arg1 = (Dali::Vector3 *)jarg1;
5245   arg2 = (Dali::Vector3 *)jarg2;
5246   if (!arg2) {
5247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5248     return 0;
5249   }
5250   {
5251     try {
5252       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5253     } catch (std::out_of_range& e) {
5254       {
5255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5256       };
5257     } catch (std::exception& e) {
5258       {
5259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5260       };
5261     } catch (...) {
5262       {
5263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5264       };
5265     }
5266   }
5267   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5268   return jresult;
5269 }
5270
5271
5272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_AddAssign(void * jarg1, void * jarg2) {
5273   void * jresult ;
5274   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5275   Dali::Vector3 *arg2 = 0 ;
5276   Dali::Vector3 *result = 0 ;
5277
5278   arg1 = (Dali::Vector3 *)jarg1;
5279   arg2 = (Dali::Vector3 *)jarg2;
5280   if (!arg2) {
5281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5282     return 0;
5283   }
5284   {
5285     try {
5286       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5287     } catch (std::out_of_range& e) {
5288       {
5289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5290       };
5291     } catch (std::exception& e) {
5292       {
5293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5294       };
5295     } catch (...) {
5296       {
5297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5298       };
5299     }
5300   }
5301   jresult = (void *)result;
5302   return jresult;
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5307   void * jresult ;
5308   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5309   Dali::Vector3 *arg2 = 0 ;
5310   Dali::Vector3 result;
5311
5312   arg1 = (Dali::Vector3 *)jarg1;
5313   arg2 = (Dali::Vector3 *)jarg2;
5314   if (!arg2) {
5315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5316     return 0;
5317   }
5318   {
5319     try {
5320       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5321     } catch (std::out_of_range& e) {
5322       {
5323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (std::exception& e) {
5326       {
5327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5336   return jresult;
5337 }
5338
5339
5340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5341   void * jresult ;
5342   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5343   Dali::Vector3 *arg2 = 0 ;
5344   Dali::Vector3 *result = 0 ;
5345
5346   arg1 = (Dali::Vector3 *)jarg1;
5347   arg2 = (Dali::Vector3 *)jarg2;
5348   if (!arg2) {
5349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5350     return 0;
5351   }
5352   {
5353     try {
5354       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5355     } catch (std::out_of_range& e) {
5356       {
5357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5358       };
5359     } catch (std::exception& e) {
5360       {
5361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5362       };
5363     } catch (...) {
5364       {
5365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5366       };
5367     }
5368   }
5369   jresult = (void *)result;
5370   return jresult;
5371 }
5372
5373
5374 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5375   void * jresult ;
5376   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5377   Dali::Vector3 *arg2 = 0 ;
5378   Dali::Vector3 result;
5379
5380   arg1 = (Dali::Vector3 *)jarg1;
5381   arg2 = (Dali::Vector3 *)jarg2;
5382   if (!arg2) {
5383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5384     return 0;
5385   }
5386   {
5387     try {
5388       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5389     } catch (std::out_of_range& e) {
5390       {
5391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5392       };
5393     } catch (std::exception& e) {
5394       {
5395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5396       };
5397     } catch (...) {
5398       {
5399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5400       };
5401     }
5402   }
5403   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5404   return jresult;
5405 }
5406
5407
5408 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5409   void * jresult ;
5410   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5411   float arg2 ;
5412   Dali::Vector3 result;
5413
5414   arg1 = (Dali::Vector3 *)jarg1;
5415   arg2 = (float)jarg2;
5416   {
5417     try {
5418       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5419     } catch (std::out_of_range& e) {
5420       {
5421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5422       };
5423     } catch (std::exception& e) {
5424       {
5425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5426       };
5427     } catch (...) {
5428       {
5429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5430       };
5431     }
5432   }
5433   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5434   return jresult;
5435 }
5436
5437
5438 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5439   void * jresult ;
5440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5441   Dali::Vector3 *arg2 = 0 ;
5442   Dali::Vector3 *result = 0 ;
5443
5444   arg1 = (Dali::Vector3 *)jarg1;
5445   arg2 = (Dali::Vector3 *)jarg2;
5446   if (!arg2) {
5447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5448     return 0;
5449   }
5450   {
5451     try {
5452       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5453     } catch (std::out_of_range& e) {
5454       {
5455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5456       };
5457     } catch (std::exception& e) {
5458       {
5459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5460       };
5461     } catch (...) {
5462       {
5463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5464       };
5465     }
5466   }
5467   jresult = (void *)result;
5468   return jresult;
5469 }
5470
5471
5472 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5473   void * jresult ;
5474   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5475   float arg2 ;
5476   Dali::Vector3 *result = 0 ;
5477
5478   arg1 = (Dali::Vector3 *)jarg1;
5479   arg2 = (float)jarg2;
5480   {
5481     try {
5482       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5483     } catch (std::out_of_range& e) {
5484       {
5485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5486       };
5487     } catch (std::exception& e) {
5488       {
5489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5490       };
5491     } catch (...) {
5492       {
5493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5494       };
5495     }
5496   }
5497   jresult = (void *)result;
5498   return jresult;
5499 }
5500
5501
5502 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5503   void * jresult ;
5504   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5505   Dali::Quaternion *arg2 = 0 ;
5506   Dali::Vector3 *result = 0 ;
5507
5508   arg1 = (Dali::Vector3 *)jarg1;
5509   arg2 = (Dali::Quaternion *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (...) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5528       };
5529     }
5530   }
5531   jresult = (void *)result;
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5537   void * jresult ;
5538   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5539   Dali::Vector3 *arg2 = 0 ;
5540   Dali::Vector3 result;
5541
5542   arg1 = (Dali::Vector3 *)jarg1;
5543   arg2 = (Dali::Vector3 *)jarg2;
5544   if (!arg2) {
5545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5546     return 0;
5547   }
5548   {
5549     try {
5550       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5551     } catch (std::out_of_range& e) {
5552       {
5553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (std::exception& e) {
5556       {
5557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5558       };
5559     } catch (...) {
5560       {
5561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5562       };
5563     }
5564   }
5565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5566   return jresult;
5567 }
5568
5569
5570 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5571   void * jresult ;
5572   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5573   float arg2 ;
5574   Dali::Vector3 result;
5575
5576   arg1 = (Dali::Vector3 *)jarg1;
5577   arg2 = (float)jarg2;
5578   {
5579     try {
5580       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5581     } catch (std::out_of_range& e) {
5582       {
5583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5584       };
5585     } catch (std::exception& e) {
5586       {
5587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5588       };
5589     } catch (...) {
5590       {
5591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5592       };
5593     }
5594   }
5595   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5596   return jresult;
5597 }
5598
5599
5600 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5601   void * jresult ;
5602   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5603   Dali::Vector3 *arg2 = 0 ;
5604   Dali::Vector3 *result = 0 ;
5605
5606   arg1 = (Dali::Vector3 *)jarg1;
5607   arg2 = (Dali::Vector3 *)jarg2;
5608   if (!arg2) {
5609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5610     return 0;
5611   }
5612   {
5613     try {
5614       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5615     } catch (std::out_of_range& e) {
5616       {
5617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (std::exception& e) {
5620       {
5621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (...) {
5624       {
5625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5626       };
5627     }
5628   }
5629   jresult = (void *)result;
5630   return jresult;
5631 }
5632
5633
5634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5635   void * jresult ;
5636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5637   float arg2 ;
5638   Dali::Vector3 *result = 0 ;
5639
5640   arg1 = (Dali::Vector3 *)jarg1;
5641   arg2 = (float)jarg2;
5642   {
5643     try {
5644       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5645     } catch (std::out_of_range& e) {
5646       {
5647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5648       };
5649     } catch (std::exception& e) {
5650       {
5651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5652       };
5653     } catch (...) {
5654       {
5655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5656       };
5657     }
5658   }
5659   jresult = (void *)result;
5660   return jresult;
5661 }
5662
5663
5664 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Subtract__SWIG_1(void * jarg1) {
5665   void * jresult ;
5666   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5667   Dali::Vector3 result;
5668
5669   arg1 = (Dali::Vector3 *)jarg1;
5670   {
5671     try {
5672       result = ((Dali::Vector3 const *)arg1)->operator -();
5673     } catch (std::out_of_range& e) {
5674       {
5675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5676       };
5677     } catch (std::exception& e) {
5678       {
5679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5680       };
5681     } catch (...) {
5682       {
5683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5684       };
5685     }
5686   }
5687   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector3_EqualTo(void * jarg1, void * jarg2) {
5693   unsigned int jresult ;
5694   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5695   Dali::Vector3 *arg2 = 0 ;
5696   bool result;
5697
5698   arg1 = (Dali::Vector3 *)jarg1;
5699   arg2 = (Dali::Vector3 *)jarg2;
5700   if (!arg2) {
5701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5702     return 0;
5703   }
5704   {
5705     try {
5706       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5707     } catch (std::out_of_range& e) {
5708       {
5709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5710       };
5711     } catch (std::exception& e) {
5712       {
5713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5714       };
5715     } catch (...) {
5716       {
5717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5718       };
5719     }
5720   }
5721   jresult = result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5727   unsigned int jresult ;
5728   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5729   Dali::Vector3 *arg2 = 0 ;
5730   bool result;
5731
5732   arg1 = (Dali::Vector3 *)jarg1;
5733   arg2 = (Dali::Vector3 *)jarg2;
5734   if (!arg2) {
5735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5736     return 0;
5737   }
5738   {
5739     try {
5740       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5741     } catch (std::out_of_range& e) {
5742       {
5743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5744       };
5745     } catch (std::exception& e) {
5746       {
5747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5748       };
5749     } catch (...) {
5750       {
5751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5752       };
5753     }
5754   }
5755   jresult = result;
5756   return jresult;
5757 }
5758
5759
5760 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5761   float jresult ;
5762   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5763   unsigned int arg2 ;
5764   float *result = 0 ;
5765
5766   arg1 = (Dali::Vector3 *)jarg1;
5767   arg2 = (unsigned int)jarg2;
5768   {
5769     try {
5770       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5771     } catch (std::out_of_range& e) {
5772       {
5773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5774       };
5775     } catch (std::exception& e) {
5776       {
5777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5778       };
5779     } catch (...) {
5780       {
5781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5782       };
5783     }
5784   }
5785   jresult = *result;
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Dot(void * jarg1, void * jarg2) {
5791   float jresult ;
5792   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5793   Dali::Vector3 *arg2 = 0 ;
5794   float result;
5795
5796   arg1 = (Dali::Vector3 *)jarg1;
5797   arg2 = (Dali::Vector3 *)jarg2;
5798   if (!arg2) {
5799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5800     return 0;
5801   }
5802   {
5803     try {
5804       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5805     } catch (std::out_of_range& e) {
5806       {
5807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5808       };
5809     } catch (std::exception& e) {
5810       {
5811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5812       };
5813     } catch (...) {
5814       {
5815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5816       };
5817     }
5818   }
5819   jresult = result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Cross(void * jarg1, void * jarg2) {
5825   void * jresult ;
5826   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5827   Dali::Vector3 *arg2 = 0 ;
5828   Dali::Vector3 result;
5829
5830   arg1 = (Dali::Vector3 *)jarg1;
5831   arg2 = (Dali::Vector3 *)jarg2;
5832   if (!arg2) {
5833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5834     return 0;
5835   }
5836   {
5837     try {
5838       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5839     } catch (std::out_of_range& e) {
5840       {
5841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5842       };
5843     } catch (std::exception& e) {
5844       {
5845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5846       };
5847     } catch (...) {
5848       {
5849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5850       };
5851     }
5852   }
5853   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Length(void * jarg1) {
5859   float jresult ;
5860   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5861   float result;
5862
5863   arg1 = (Dali::Vector3 *)jarg1;
5864   {
5865     try {
5866       result = (float)((Dali::Vector3 const *)arg1)->Length();
5867     } catch (std::out_of_range& e) {
5868       {
5869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5870       };
5871     } catch (std::exception& e) {
5872       {
5873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5874       };
5875     } catch (...) {
5876       {
5877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5878       };
5879     }
5880   }
5881   jresult = result;
5882   return jresult;
5883 }
5884
5885
5886 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_LengthSquared(void * jarg1) {
5887   float jresult ;
5888   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5889   float result;
5890
5891   arg1 = (Dali::Vector3 *)jarg1;
5892   {
5893     try {
5894       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5895     } catch (std::out_of_range& e) {
5896       {
5897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5898       };
5899     } catch (std::exception& e) {
5900       {
5901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (...) {
5904       {
5905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5906       };
5907     }
5908   }
5909   jresult = result;
5910   return jresult;
5911 }
5912
5913
5914 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Normalize(void * jarg1) {
5915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5916
5917   arg1 = (Dali::Vector3 *)jarg1;
5918   {
5919     try {
5920       (arg1)->Normalize();
5921     } catch (std::out_of_range& e) {
5922       {
5923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5924       };
5925     } catch (std::exception& e) {
5926       {
5927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5928       };
5929     } catch (...) {
5930       {
5931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5932       };
5933     }
5934   }
5935 }
5936
5937
5938 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5940   Dali::Vector3 *arg2 = 0 ;
5941   Dali::Vector3 *arg3 = 0 ;
5942
5943   arg1 = (Dali::Vector3 *)jarg1;
5944   arg2 = (Dali::Vector3 *)jarg2;
5945   if (!arg2) {
5946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5947     return ;
5948   }
5949   arg3 = (Dali::Vector3 *)jarg3;
5950   if (!arg3) {
5951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5952     return ;
5953   }
5954   {
5955     try {
5956       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
5957     } catch (std::out_of_range& e) {
5958       {
5959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5960       };
5961     } catch (std::exception& e) {
5962       {
5963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5964       };
5965     } catch (...) {
5966       {
5967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5968       };
5969     }
5970   }
5971 }
5972
5973
5974 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_AsFloat__SWIG_0(void * jarg1) {
5975   void * jresult ;
5976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5977   float *result = 0 ;
5978
5979   arg1 = (Dali::Vector3 *)jarg1;
5980   {
5981     try {
5982       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
5983     } catch (std::out_of_range& e) {
5984       {
5985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5986       };
5987     } catch (std::exception& e) {
5988       {
5989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5990       };
5991     } catch (...) {
5992       {
5993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5994       };
5995     }
5996   }
5997   jresult = (void *)result;
5998   return jresult;
5999 }
6000
6001
6002 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6003   void * jresult ;
6004   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6005   Dali::Vector2 *result = 0 ;
6006
6007   arg1 = (Dali::Vector3 *)jarg1;
6008   {
6009     try {
6010       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6011     } catch (std::out_of_range& e) {
6012       {
6013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (std::exception& e) {
6016       {
6017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (...) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6022       };
6023     }
6024   }
6025   jresult = (void *)result;
6026   return jresult;
6027 }
6028
6029
6030 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6031   void * jresult ;
6032   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6033   Dali::Vector2 *result = 0 ;
6034
6035   arg1 = (Dali::Vector3 *)jarg1;
6036   {
6037     try {
6038       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6039     } catch (std::out_of_range& e) {
6040       {
6041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6042       };
6043     } catch (std::exception& e) {
6044       {
6045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6046       };
6047     } catch (...) {
6048       {
6049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6050       };
6051     }
6052   }
6053   jresult = (void *)result;
6054   return jresult;
6055 }
6056
6057
6058 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_X_set(void * jarg1, float jarg2) {
6059   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6060   float arg2 ;
6061
6062   arg1 = (Dali::Vector3 *)jarg1;
6063   arg2 = (float)jarg2;
6064   if (arg1) (arg1)->x = arg2;
6065 }
6066
6067
6068 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_X_get(void * jarg1) {
6069   float jresult ;
6070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6071   float result;
6072
6073   arg1 = (Dali::Vector3 *)jarg1;
6074   result = (float) ((arg1)->x);
6075   jresult = result;
6076   return jresult;
6077 }
6078
6079
6080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Width_set(void * jarg1, float jarg2) {
6081   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6082   float arg2 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (float)jarg2;
6086   if (arg1) (arg1)->width = arg2;
6087 }
6088
6089
6090 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Width_get(void * jarg1) {
6091   float jresult ;
6092   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6093   float result;
6094
6095   arg1 = (Dali::Vector3 *)jarg1;
6096   result = (float) ((arg1)->width);
6097   jresult = result;
6098   return jresult;
6099 }
6100
6101
6102 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_r_set(void * jarg1, float jarg2) {
6103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6104   float arg2 ;
6105
6106   arg1 = (Dali::Vector3 *)jarg1;
6107   arg2 = (float)jarg2;
6108   if (arg1) (arg1)->r = arg2;
6109 }
6110
6111
6112 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_r_get(void * jarg1) {
6113   float jresult ;
6114   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6115   float result;
6116
6117   arg1 = (Dali::Vector3 *)jarg1;
6118   result = (float) ((arg1)->r);
6119   jresult = result;
6120   return jresult;
6121 }
6122
6123
6124 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Y_set(void * jarg1, float jarg2) {
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   float arg2 ;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (float)jarg2;
6130   if (arg1) (arg1)->y = arg2;
6131 }
6132
6133
6134 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Y_get(void * jarg1) {
6135   float jresult ;
6136   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6137   float result;
6138
6139   arg1 = (Dali::Vector3 *)jarg1;
6140   result = (float) ((arg1)->y);
6141   jresult = result;
6142   return jresult;
6143 }
6144
6145
6146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Height_set(void * jarg1, float jarg2) {
6147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6148   float arg2 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   arg2 = (float)jarg2;
6152   if (arg1) (arg1)->height = arg2;
6153 }
6154
6155
6156 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Height_get(void * jarg1) {
6157   float jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float result;
6160
6161   arg1 = (Dali::Vector3 *)jarg1;
6162   result = (float) ((arg1)->height);
6163   jresult = result;
6164   return jresult;
6165 }
6166
6167
6168 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_g_set(void * jarg1, float jarg2) {
6169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6170   float arg2 ;
6171
6172   arg1 = (Dali::Vector3 *)jarg1;
6173   arg2 = (float)jarg2;
6174   if (arg1) (arg1)->g = arg2;
6175 }
6176
6177
6178 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_g_get(void * jarg1) {
6179   float jresult ;
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   float result;
6182
6183   arg1 = (Dali::Vector3 *)jarg1;
6184   result = (float) ((arg1)->g);
6185   jresult = result;
6186   return jresult;
6187 }
6188
6189
6190 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Z_set(void * jarg1, float jarg2) {
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   float arg2 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (float)jarg2;
6196   if (arg1) (arg1)->z = arg2;
6197 }
6198
6199
6200 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Z_get(void * jarg1) {
6201   float jresult ;
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float result;
6204
6205   arg1 = (Dali::Vector3 *)jarg1;
6206   result = (float) ((arg1)->z);
6207   jresult = result;
6208   return jresult;
6209 }
6210
6211
6212 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Depth_set(void * jarg1, float jarg2) {
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   float arg2 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   arg2 = (float)jarg2;
6218   if (arg1) (arg1)->depth = arg2;
6219 }
6220
6221
6222 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Depth_get(void * jarg1) {
6223   float jresult ;
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float result;
6226
6227   arg1 = (Dali::Vector3 *)jarg1;
6228   result = (float) ((arg1)->depth);
6229   jresult = result;
6230   return jresult;
6231 }
6232
6233
6234 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_b_set(void * jarg1, float jarg2) {
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float arg2 ;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   arg2 = (float)jarg2;
6240   if (arg1) (arg1)->b = arg2;
6241 }
6242
6243
6244 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_b_get(void * jarg1) {
6245   float jresult ;
6246   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6247   float result;
6248
6249   arg1 = (Dali::Vector3 *)jarg1;
6250   result = (float) ((arg1)->b);
6251   jresult = result;
6252   return jresult;
6253 }
6254
6255
6256 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector3(void * jarg1) {
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258
6259   arg1 = (Dali::Vector3 *)jarg1;
6260   {
6261     try {
6262       delete arg1;
6263     } catch (std::out_of_range& e) {
6264       {
6265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6266       };
6267     } catch (std::exception& e) {
6268       {
6269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6270       };
6271     } catch (...) {
6272       {
6273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6274       };
6275     }
6276   }
6277 }
6278
6279
6280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_1(void * jarg1, void * jarg2) {
6281   void * jresult ;
6282   Dali::Vector3 *arg1 = 0 ;
6283   Dali::Vector3 *arg2 = 0 ;
6284   Dali::Vector3 result;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   if (!arg1) {
6288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6289     return 0;
6290   }
6291   arg2 = (Dali::Vector3 *)jarg2;
6292   if (!arg2) {
6293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6294     return 0;
6295   }
6296   {
6297     try {
6298       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6299     } catch (std::out_of_range& e) {
6300       {
6301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6302       };
6303     } catch (std::exception& e) {
6304       {
6305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6306       };
6307     } catch (...) {
6308       {
6309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6310       };
6311     }
6312   }
6313   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6314   return jresult;
6315 }
6316
6317
6318 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_1(void * jarg1, void * jarg2) {
6319   void * jresult ;
6320   Dali::Vector3 *arg1 = 0 ;
6321   Dali::Vector3 *arg2 = 0 ;
6322   Dali::Vector3 result;
6323
6324   arg1 = (Dali::Vector3 *)jarg1;
6325   if (!arg1) {
6326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6327     return 0;
6328   }
6329   arg2 = (Dali::Vector3 *)jarg2;
6330   if (!arg2) {
6331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6332     return 0;
6333   }
6334   {
6335     try {
6336       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6337     } catch (std::out_of_range& e) {
6338       {
6339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6340       };
6341     } catch (std::exception& e) {
6342       {
6343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6344       };
6345     } catch (...) {
6346       {
6347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6348       };
6349     }
6350   }
6351   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6352   return jresult;
6353 }
6354
6355
6356 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6357   void * jresult ;
6358   Dali::Vector3 *arg1 = 0 ;
6359   float *arg2 = 0 ;
6360   float *arg3 = 0 ;
6361   float temp2 ;
6362   float temp3 ;
6363   Dali::Vector3 result;
6364
6365   arg1 = (Dali::Vector3 *)jarg1;
6366   if (!arg1) {
6367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6368     return 0;
6369   }
6370   temp2 = (float)jarg2;
6371   arg2 = &temp2;
6372   temp3 = (float)jarg3;
6373   arg3 = &temp3;
6374   {
6375     try {
6376       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6377     } catch (std::out_of_range& e) {
6378       {
6379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6380       };
6381     } catch (std::exception& e) {
6382       {
6383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (...) {
6386       {
6387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6388       };
6389     }
6390   }
6391   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6392   return jresult;
6393 }
6394
6395
6396 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_0() {
6397   void * jresult ;
6398   Dali::Vector4 *result = 0 ;
6399
6400   {
6401     try {
6402       result = (Dali::Vector4 *)new Dali::Vector4();
6403     } catch (std::out_of_range& e) {
6404       {
6405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6406       };
6407     } catch (std::exception& e) {
6408       {
6409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6410       };
6411     } catch (...) {
6412       {
6413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6414       };
6415     }
6416   }
6417   jresult = (void *)result;
6418   return jresult;
6419 }
6420
6421
6422 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6423   void * jresult ;
6424   float arg1 ;
6425   float arg2 ;
6426   float arg3 ;
6427   float arg4 ;
6428   Dali::Vector4 *result = 0 ;
6429
6430   arg1 = (float)jarg1;
6431   arg2 = (float)jarg2;
6432   arg3 = (float)jarg3;
6433   arg4 = (float)jarg4;
6434   {
6435     try {
6436       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6437     } catch (std::out_of_range& e) {
6438       {
6439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6440       };
6441     } catch (std::exception& e) {
6442       {
6443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6444       };
6445     } catch (...) {
6446       {
6447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6448       };
6449     }
6450   }
6451   jresult = (void *)result;
6452   return jresult;
6453 }
6454
6455
6456 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_2(float* jarg1) {
6457   void * jresult ;
6458   float *arg1 = (float *) 0 ;
6459   Dali::Vector4 *result = 0 ;
6460
6461   arg1 = jarg1;
6462   {
6463     try {
6464       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6465     } catch (std::out_of_range& e) {
6466       {
6467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (std::exception& e) {
6470       {
6471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479   jresult = (void *)result;
6480
6481
6482   return jresult;
6483 }
6484
6485
6486 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_3(void * jarg1) {
6487   void * jresult ;
6488   Dali::Vector2 *arg1 = 0 ;
6489   Dali::Vector4 *result = 0 ;
6490
6491   arg1 = (Dali::Vector2 *)jarg1;
6492   if (!arg1) {
6493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6494     return 0;
6495   }
6496   {
6497     try {
6498       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6499     } catch (std::out_of_range& e) {
6500       {
6501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (std::exception& e) {
6504       {
6505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6506       };
6507     } catch (...) {
6508       {
6509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6510       };
6511     }
6512   }
6513   jresult = (void *)result;
6514   return jresult;
6515 }
6516
6517
6518 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_4(void * jarg1) {
6519   void * jresult ;
6520   Dali::Vector3 *arg1 = 0 ;
6521   Dali::Vector4 *result = 0 ;
6522
6523   arg1 = (Dali::Vector3 *)jarg1;
6524   if (!arg1) {
6525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6526     return 0;
6527   }
6528   {
6529     try {
6530       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6531     } catch (std::out_of_range& e) {
6532       {
6533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (std::exception& e) {
6536       {
6537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (...) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6542       };
6543     }
6544   }
6545   jresult = (void *)result;
6546   return jresult;
6547 }
6548
6549
6550 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ONE_get() {
6551   void * jresult ;
6552   Dali::Vector4 *result = 0 ;
6553
6554   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6555   jresult = (void *)result;
6556   return jresult;
6557 }
6558
6559
6560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_XAXIS_get() {
6561   void * jresult ;
6562   Dali::Vector4 *result = 0 ;
6563
6564   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6565   jresult = (void *)result;
6566   return jresult;
6567 }
6568
6569
6570 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_YAXIS_get() {
6571   void * jresult ;
6572   Dali::Vector4 *result = 0 ;
6573
6574   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6575   jresult = (void *)result;
6576   return jresult;
6577 }
6578
6579
6580 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ZAXIS_get() {
6581   void * jresult ;
6582   Dali::Vector4 *result = 0 ;
6583
6584   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6585   jresult = (void *)result;
6586   return jresult;
6587 }
6588
6589
6590 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ZERO_get() {
6591   void * jresult ;
6592   Dali::Vector4 *result = 0 ;
6593
6594   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6595   jresult = (void *)result;
6596   return jresult;
6597 }
6598
6599
6600 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6601   void * jresult ;
6602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6603   float *arg2 = (float *) 0 ;
6604   Dali::Vector4 *result = 0 ;
6605
6606   arg1 = (Dali::Vector4 *)jarg1;
6607   arg2 = jarg2;
6608   {
6609     try {
6610       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6622       };
6623     }
6624   }
6625   jresult = (void *)result;
6626
6627
6628   return jresult;
6629 }
6630
6631
6632 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6633   void * jresult ;
6634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6635   Dali::Vector2 *arg2 = 0 ;
6636   Dali::Vector4 *result = 0 ;
6637
6638   arg1 = (Dali::Vector4 *)jarg1;
6639   arg2 = (Dali::Vector2 *)jarg2;
6640   if (!arg2) {
6641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6642     return 0;
6643   }
6644   {
6645     try {
6646       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6647     } catch (std::out_of_range& e) {
6648       {
6649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6650       };
6651     } catch (std::exception& e) {
6652       {
6653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6654       };
6655     } catch (...) {
6656       {
6657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6658       };
6659     }
6660   }
6661   jresult = (void *)result;
6662   return jresult;
6663 }
6664
6665
6666 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6667   void * jresult ;
6668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6669   Dali::Vector3 *arg2 = 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector4 *)jarg1;
6673   arg2 = (Dali::Vector3 *)jarg2;
6674   if (!arg2) {
6675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6676     return 0;
6677   }
6678   {
6679     try {
6680       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6681     } catch (std::out_of_range& e) {
6682       {
6683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (std::exception& e) {
6686       {
6687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (...) {
6690       {
6691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6692       };
6693     }
6694   }
6695   jresult = (void *)result;
6696   return jresult;
6697 }
6698
6699
6700 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Add(void * jarg1, void * jarg2) {
6701   void * jresult ;
6702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6703   Dali::Vector4 *arg2 = 0 ;
6704   Dali::Vector4 result;
6705
6706   arg1 = (Dali::Vector4 *)jarg1;
6707   arg2 = (Dali::Vector4 *)jarg2;
6708   if (!arg2) {
6709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6710     return 0;
6711   }
6712   {
6713     try {
6714       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6715     } catch (std::out_of_range& e) {
6716       {
6717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (std::exception& e) {
6720       {
6721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6722       };
6723     } catch (...) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6726       };
6727     }
6728   }
6729   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6730   return jresult;
6731 }
6732
6733
6734 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_AddAssign(void * jarg1, void * jarg2) {
6735   void * jresult ;
6736   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6737   Dali::Vector4 *arg2 = 0 ;
6738   Dali::Vector4 *result = 0 ;
6739
6740   arg1 = (Dali::Vector4 *)jarg1;
6741   arg2 = (Dali::Vector4 *)jarg2;
6742   if (!arg2) {
6743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6744     return 0;
6745   }
6746   {
6747     try {
6748       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6756       };
6757     } catch (...) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6760       };
6761     }
6762   }
6763   jresult = (void *)result;
6764   return jresult;
6765 }
6766
6767
6768 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6769   void * jresult ;
6770   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6771   Dali::Vector4 *arg2 = 0 ;
6772   Dali::Vector4 result;
6773
6774   arg1 = (Dali::Vector4 *)jarg1;
6775   arg2 = (Dali::Vector4 *)jarg2;
6776   if (!arg2) {
6777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6778     return 0;
6779   }
6780   {
6781     try {
6782       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6783     } catch (std::out_of_range& e) {
6784       {
6785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6786       };
6787     } catch (std::exception& e) {
6788       {
6789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6790       };
6791     } catch (...) {
6792       {
6793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6794       };
6795     }
6796   }
6797   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6798   return jresult;
6799 }
6800
6801
6802 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6803   void * jresult ;
6804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6805   Dali::Vector4 *arg2 = 0 ;
6806   Dali::Vector4 *result = 0 ;
6807
6808   arg1 = (Dali::Vector4 *)jarg1;
6809   arg2 = (Dali::Vector4 *)jarg2;
6810   if (!arg2) {
6811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6812     return 0;
6813   }
6814   {
6815     try {
6816       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6817     } catch (std::out_of_range& e) {
6818       {
6819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (std::exception& e) {
6822       {
6823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (...) {
6826       {
6827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6828       };
6829     }
6830   }
6831   jresult = (void *)result;
6832   return jresult;
6833 }
6834
6835
6836 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6837   void * jresult ;
6838   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6839   Dali::Vector4 *arg2 = 0 ;
6840   Dali::Vector4 result;
6841
6842   arg1 = (Dali::Vector4 *)jarg1;
6843   arg2 = (Dali::Vector4 *)jarg2;
6844   if (!arg2) {
6845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6846     return 0;
6847   }
6848   {
6849     try {
6850       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6851     } catch (std::out_of_range& e) {
6852       {
6853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (std::exception& e) {
6856       {
6857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6858       };
6859     } catch (...) {
6860       {
6861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6862       };
6863     }
6864   }
6865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6871   void * jresult ;
6872   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6873   float arg2 ;
6874   Dali::Vector4 result;
6875
6876   arg1 = (Dali::Vector4 *)jarg1;
6877   arg2 = (float)jarg2;
6878   {
6879     try {
6880       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6881     } catch (std::out_of_range& e) {
6882       {
6883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6884       };
6885     } catch (std::exception& e) {
6886       {
6887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (...) {
6890       {
6891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6892       };
6893     }
6894   }
6895   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6901   void * jresult ;
6902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6903   Dali::Vector4 *arg2 = 0 ;
6904   Dali::Vector4 *result = 0 ;
6905
6906   arg1 = (Dali::Vector4 *)jarg1;
6907   arg2 = (Dali::Vector4 *)jarg2;
6908   if (!arg2) {
6909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6910     return 0;
6911   }
6912   {
6913     try {
6914       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6915     } catch (std::out_of_range& e) {
6916       {
6917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6918       };
6919     } catch (std::exception& e) {
6920       {
6921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6922       };
6923     } catch (...) {
6924       {
6925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6926       };
6927     }
6928   }
6929   jresult = (void *)result;
6930   return jresult;
6931 }
6932
6933
6934 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6935   void * jresult ;
6936   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6937   float arg2 ;
6938   Dali::Vector4 *result = 0 ;
6939
6940   arg1 = (Dali::Vector4 *)jarg1;
6941   arg2 = (float)jarg2;
6942   {
6943     try {
6944       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
6945     } catch (std::out_of_range& e) {
6946       {
6947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6948       };
6949     } catch (std::exception& e) {
6950       {
6951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6952       };
6953     } catch (...) {
6954       {
6955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6956       };
6957     }
6958   }
6959   jresult = (void *)result;
6960   return jresult;
6961 }
6962
6963
6964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
6965   void * jresult ;
6966   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6967   Dali::Vector4 *arg2 = 0 ;
6968   Dali::Vector4 result;
6969
6970   arg1 = (Dali::Vector4 *)jarg1;
6971   arg2 = (Dali::Vector4 *)jarg2;
6972   if (!arg2) {
6973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6974     return 0;
6975   }
6976   {
6977     try {
6978       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
6979     } catch (std::out_of_range& e) {
6980       {
6981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6982       };
6983     } catch (std::exception& e) {
6984       {
6985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6986       };
6987     } catch (...) {
6988       {
6989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6990       };
6991     }
6992   }
6993   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6994   return jresult;
6995 }
6996
6997
6998 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
6999   void * jresult ;
7000   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7001   float arg2 ;
7002   Dali::Vector4 result;
7003
7004   arg1 = (Dali::Vector4 *)jarg1;
7005   arg2 = (float)jarg2;
7006   {
7007     try {
7008       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7009     } catch (std::out_of_range& e) {
7010       {
7011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7012       };
7013     } catch (std::exception& e) {
7014       {
7015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7016       };
7017     } catch (...) {
7018       {
7019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7020       };
7021     }
7022   }
7023   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7024   return jresult;
7025 }
7026
7027
7028 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7029   void * jresult ;
7030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7031   Dali::Vector4 *arg2 = 0 ;
7032   Dali::Vector4 *result = 0 ;
7033
7034   arg1 = (Dali::Vector4 *)jarg1;
7035   arg2 = (Dali::Vector4 *)jarg2;
7036   if (!arg2) {
7037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7038     return 0;
7039   }
7040   {
7041     try {
7042       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7043     } catch (std::out_of_range& e) {
7044       {
7045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7046       };
7047     } catch (std::exception& e) {
7048       {
7049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7050       };
7051     } catch (...) {
7052       {
7053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7054       };
7055     }
7056   }
7057   jresult = (void *)result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7063   void * jresult ;
7064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7065   float arg2 ;
7066   Dali::Vector4 *result = 0 ;
7067
7068   arg1 = (Dali::Vector4 *)jarg1;
7069   arg2 = (float)jarg2;
7070   {
7071     try {
7072       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7073     } catch (std::out_of_range& e) {
7074       {
7075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7076       };
7077     } catch (std::exception& e) {
7078       {
7079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7080       };
7081     } catch (...) {
7082       {
7083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7084       };
7085     }
7086   }
7087   jresult = (void *)result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Subtract__SWIG_1(void * jarg1) {
7093   void * jresult ;
7094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7095   Dali::Vector4 result;
7096
7097   arg1 = (Dali::Vector4 *)jarg1;
7098   {
7099     try {
7100       result = ((Dali::Vector4 const *)arg1)->operator -();
7101     } catch (std::out_of_range& e) {
7102       {
7103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7104       };
7105     } catch (std::exception& e) {
7106       {
7107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7108       };
7109     } catch (...) {
7110       {
7111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7112       };
7113     }
7114   }
7115   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7116   return jresult;
7117 }
7118
7119
7120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector4_EqualTo(void * jarg1, void * jarg2) {
7121   unsigned int jresult ;
7122   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7123   Dali::Vector4 *arg2 = 0 ;
7124   bool result;
7125
7126   arg1 = (Dali::Vector4 *)jarg1;
7127   arg2 = (Dali::Vector4 *)jarg2;
7128   if (!arg2) {
7129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7130     return 0;
7131   }
7132   {
7133     try {
7134       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7135     } catch (std::out_of_range& e) {
7136       {
7137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7138       };
7139     } catch (std::exception& e) {
7140       {
7141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7142       };
7143     } catch (...) {
7144       {
7145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7146       };
7147     }
7148   }
7149   jresult = result;
7150   return jresult;
7151 }
7152
7153
7154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7155   unsigned int jresult ;
7156   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7157   Dali::Vector4 *arg2 = 0 ;
7158   bool result;
7159
7160   arg1 = (Dali::Vector4 *)jarg1;
7161   arg2 = (Dali::Vector4 *)jarg2;
7162   if (!arg2) {
7163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7164     return 0;
7165   }
7166   {
7167     try {
7168       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7169     } catch (std::out_of_range& e) {
7170       {
7171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7172       };
7173     } catch (std::exception& e) {
7174       {
7175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7176       };
7177     } catch (...) {
7178       {
7179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7180       };
7181     }
7182   }
7183   jresult = result;
7184   return jresult;
7185 }
7186
7187
7188 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7189   float jresult ;
7190   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7191   unsigned int arg2 ;
7192   float *result = 0 ;
7193
7194   arg1 = (Dali::Vector4 *)jarg1;
7195   arg2 = (unsigned int)jarg2;
7196   {
7197     try {
7198       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7199     } catch (std::out_of_range& e) {
7200       {
7201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (std::exception& e) {
7204       {
7205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213   jresult = *result;
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7219   float jresult ;
7220   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7221   Dali::Vector3 *arg2 = 0 ;
7222   float result;
7223
7224   arg1 = (Dali::Vector4 *)jarg1;
7225   arg2 = (Dali::Vector3 *)jarg2;
7226   if (!arg2) {
7227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7228     return 0;
7229   }
7230   {
7231     try {
7232       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7233     } catch (std::out_of_range& e) {
7234       {
7235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (std::exception& e) {
7238       {
7239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247   jresult = result;
7248   return jresult;
7249 }
7250
7251
7252 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7253   float jresult ;
7254   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7255   Dali::Vector4 *arg2 = 0 ;
7256   float result;
7257
7258   arg1 = (Dali::Vector4 *)jarg1;
7259   arg2 = (Dali::Vector4 *)jarg2;
7260   if (!arg2) {
7261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7262     return 0;
7263   }
7264   {
7265     try {
7266       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7267     } catch (std::out_of_range& e) {
7268       {
7269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (std::exception& e) {
7272       {
7273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (...) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7278       };
7279     }
7280   }
7281   jresult = result;
7282   return jresult;
7283 }
7284
7285
7286 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot4(void * jarg1, void * jarg2) {
7287   float jresult ;
7288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7289   Dali::Vector4 *arg2 = 0 ;
7290   float result;
7291
7292   arg1 = (Dali::Vector4 *)jarg1;
7293   arg2 = (Dali::Vector4 *)jarg2;
7294   if (!arg2) {
7295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7296     return 0;
7297   }
7298   {
7299     try {
7300       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7301     } catch (std::out_of_range& e) {
7302       {
7303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (std::exception& e) {
7306       {
7307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7308       };
7309     } catch (...) {
7310       {
7311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7312       };
7313     }
7314   }
7315   jresult = result;
7316   return jresult;
7317 }
7318
7319
7320 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Cross(void * jarg1, void * jarg2) {
7321   void * jresult ;
7322   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7323   Dali::Vector4 *arg2 = 0 ;
7324   Dali::Vector4 result;
7325
7326   arg1 = (Dali::Vector4 *)jarg1;
7327   arg2 = (Dali::Vector4 *)jarg2;
7328   if (!arg2) {
7329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7330     return 0;
7331   }
7332   {
7333     try {
7334       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7335     } catch (std::out_of_range& e) {
7336       {
7337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7338       };
7339     } catch (std::exception& e) {
7340       {
7341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7342       };
7343     } catch (...) {
7344       {
7345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7346       };
7347     }
7348   }
7349   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7350   return jresult;
7351 }
7352
7353
7354 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Length(void * jarg1) {
7355   float jresult ;
7356   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7357   float result;
7358
7359   arg1 = (Dali::Vector4 *)jarg1;
7360   {
7361     try {
7362       result = (float)((Dali::Vector4 const *)arg1)->Length();
7363     } catch (std::out_of_range& e) {
7364       {
7365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7366       };
7367     } catch (std::exception& e) {
7368       {
7369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7370       };
7371     } catch (...) {
7372       {
7373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7374       };
7375     }
7376   }
7377   jresult = result;
7378   return jresult;
7379 }
7380
7381
7382 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_LengthSquared(void * jarg1) {
7383   float jresult ;
7384   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7385   float result;
7386
7387   arg1 = (Dali::Vector4 *)jarg1;
7388   {
7389     try {
7390       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7391     } catch (std::out_of_range& e) {
7392       {
7393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (std::exception& e) {
7396       {
7397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405   jresult = result;
7406   return jresult;
7407 }
7408
7409
7410 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Normalize(void * jarg1) {
7411   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7412
7413   arg1 = (Dali::Vector4 *)jarg1;
7414   {
7415     try {
7416       (arg1)->Normalize();
7417     } catch (std::out_of_range& e) {
7418       {
7419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7420       };
7421     } catch (std::exception& e) {
7422       {
7423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7424       };
7425     } catch (...) {
7426       {
7427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7428       };
7429     }
7430   }
7431 }
7432
7433
7434 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7435   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7436   Dali::Vector4 *arg2 = 0 ;
7437   Dali::Vector4 *arg3 = 0 ;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   arg2 = (Dali::Vector4 *)jarg2;
7441   if (!arg2) {
7442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7443     return ;
7444   }
7445   arg3 = (Dali::Vector4 *)jarg3;
7446   if (!arg3) {
7447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7448     return ;
7449   }
7450   {
7451     try {
7452       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7453     } catch (std::out_of_range& e) {
7454       {
7455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7456       };
7457     } catch (std::exception& e) {
7458       {
7459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7460       };
7461     } catch (...) {
7462       {
7463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7464       };
7465     }
7466   }
7467 }
7468
7469
7470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_AsFloat__SWIG_0(void * jarg1) {
7471   void * jresult ;
7472   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7473   float *result = 0 ;
7474
7475   arg1 = (Dali::Vector4 *)jarg1;
7476   {
7477     try {
7478       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7479     } catch (std::out_of_range& e) {
7480       {
7481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7482       };
7483     } catch (std::exception& e) {
7484       {
7485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7486       };
7487     } catch (...) {
7488       {
7489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7490       };
7491     }
7492   }
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_X_set(void * jarg1, float jarg2) {
7499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7500   float arg2 ;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   arg2 = (float)jarg2;
7504   if (arg1) (arg1)->x = arg2;
7505 }
7506
7507
7508 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_X_get(void * jarg1) {
7509   float jresult ;
7510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7511   float result;
7512
7513   arg1 = (Dali::Vector4 *)jarg1;
7514   result = (float) ((arg1)->x);
7515   jresult = result;
7516   return jresult;
7517 }
7518
7519
7520 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_r_set(void * jarg1, float jarg2) {
7521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7522   float arg2 ;
7523
7524   arg1 = (Dali::Vector4 *)jarg1;
7525   arg2 = (float)jarg2;
7526   if (arg1) (arg1)->r = arg2;
7527 }
7528
7529
7530 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_r_get(void * jarg1) {
7531   float jresult ;
7532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7533   float result;
7534
7535   arg1 = (Dali::Vector4 *)jarg1;
7536   result = (float) ((arg1)->r);
7537   jresult = result;
7538   return jresult;
7539 }
7540
7541
7542 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_s_set(void * jarg1, float jarg2) {
7543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7544   float arg2 ;
7545
7546   arg1 = (Dali::Vector4 *)jarg1;
7547   arg2 = (float)jarg2;
7548   if (arg1) (arg1)->s = arg2;
7549 }
7550
7551
7552 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_s_get(void * jarg1) {
7553   float jresult ;
7554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7555   float result;
7556
7557   arg1 = (Dali::Vector4 *)jarg1;
7558   result = (float) ((arg1)->s);
7559   jresult = result;
7560   return jresult;
7561 }
7562
7563
7564 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Y_set(void * jarg1, float jarg2) {
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float arg2 ;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   arg2 = (float)jarg2;
7570   if (arg1) (arg1)->y = arg2;
7571 }
7572
7573
7574 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Y_get(void * jarg1) {
7575   float jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   float result;
7578
7579   arg1 = (Dali::Vector4 *)jarg1;
7580   result = (float) ((arg1)->y);
7581   jresult = result;
7582   return jresult;
7583 }
7584
7585
7586 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_g_set(void * jarg1, float jarg2) {
7587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7588   float arg2 ;
7589
7590   arg1 = (Dali::Vector4 *)jarg1;
7591   arg2 = (float)jarg2;
7592   if (arg1) (arg1)->g = arg2;
7593 }
7594
7595
7596 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_g_get(void * jarg1) {
7597   float jresult ;
7598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7599   float result;
7600
7601   arg1 = (Dali::Vector4 *)jarg1;
7602   result = (float) ((arg1)->g);
7603   jresult = result;
7604   return jresult;
7605 }
7606
7607
7608 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_t_set(void * jarg1, float jarg2) {
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   float arg2 ;
7611
7612   arg1 = (Dali::Vector4 *)jarg1;
7613   arg2 = (float)jarg2;
7614   if (arg1) (arg1)->t = arg2;
7615 }
7616
7617
7618 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_t_get(void * jarg1) {
7619   float jresult ;
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   float result;
7622
7623   arg1 = (Dali::Vector4 *)jarg1;
7624   result = (float) ((arg1)->t);
7625   jresult = result;
7626   return jresult;
7627 }
7628
7629
7630 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Z_set(void * jarg1, float jarg2) {
7631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7632   float arg2 ;
7633
7634   arg1 = (Dali::Vector4 *)jarg1;
7635   arg2 = (float)jarg2;
7636   if (arg1) (arg1)->z = arg2;
7637 }
7638
7639
7640 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Z_get(void * jarg1) {
7641   float jresult ;
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   float result;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   result = (float) ((arg1)->z);
7647   jresult = result;
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_b_set(void * jarg1, float jarg2) {
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float arg2 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (float)jarg2;
7658   if (arg1) (arg1)->b = arg2;
7659 }
7660
7661
7662 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_b_get(void * jarg1) {
7663   float jresult ;
7664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7665   float result;
7666
7667   arg1 = (Dali::Vector4 *)jarg1;
7668   result = (float) ((arg1)->b);
7669   jresult = result;
7670   return jresult;
7671 }
7672
7673
7674 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_p_set(void * jarg1, float jarg2) {
7675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7676   float arg2 ;
7677
7678   arg1 = (Dali::Vector4 *)jarg1;
7679   arg2 = (float)jarg2;
7680   if (arg1) (arg1)->p = arg2;
7681 }
7682
7683
7684 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_p_get(void * jarg1) {
7685   float jresult ;
7686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7687   float result;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   result = (float) ((arg1)->p);
7691   jresult = result;
7692   return jresult;
7693 }
7694
7695
7696 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_W_set(void * jarg1, float jarg2) {
7697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7698   float arg2 ;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   arg2 = (float)jarg2;
7702   if (arg1) (arg1)->w = arg2;
7703 }
7704
7705
7706 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_W_get(void * jarg1) {
7707   float jresult ;
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   float result;
7710
7711   arg1 = (Dali::Vector4 *)jarg1;
7712   result = (float) ((arg1)->w);
7713   jresult = result;
7714   return jresult;
7715 }
7716
7717
7718 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_a_set(void * jarg1, float jarg2) {
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   float arg2 ;
7721
7722   arg1 = (Dali::Vector4 *)jarg1;
7723   arg2 = (float)jarg2;
7724   if (arg1) (arg1)->a = arg2;
7725 }
7726
7727
7728 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_a_get(void * jarg1) {
7729   float jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   float result;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   result = (float) ((arg1)->a);
7735   jresult = result;
7736   return jresult;
7737 }
7738
7739
7740 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_q_set(void * jarg1, float jarg2) {
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float arg2 ;
7743
7744   arg1 = (Dali::Vector4 *)jarg1;
7745   arg2 = (float)jarg2;
7746   if (arg1) (arg1)->q = arg2;
7747 }
7748
7749
7750 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_q_get(void * jarg1) {
7751   float jresult ;
7752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7753   float result;
7754
7755   arg1 = (Dali::Vector4 *)jarg1;
7756   result = (float) ((arg1)->q);
7757   jresult = result;
7758   return jresult;
7759 }
7760
7761
7762 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector4(void * jarg1) {
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764
7765   arg1 = (Dali::Vector4 *)jarg1;
7766   {
7767     try {
7768       delete arg1;
7769     } catch (std::out_of_range& e) {
7770       {
7771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7772       };
7773     } catch (std::exception& e) {
7774       {
7775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7776       };
7777     } catch (...) {
7778       {
7779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7780       };
7781     }
7782   }
7783 }
7784
7785
7786 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_2(void * jarg1, void * jarg2) {
7787   void * jresult ;
7788   Dali::Vector4 *arg1 = 0 ;
7789   Dali::Vector4 *arg2 = 0 ;
7790   Dali::Vector4 result;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   if (!arg1) {
7794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7795     return 0;
7796   }
7797   arg2 = (Dali::Vector4 *)jarg2;
7798   if (!arg2) {
7799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7800     return 0;
7801   }
7802   {
7803     try {
7804       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7805     } catch (std::out_of_range& e) {
7806       {
7807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7808       };
7809     } catch (std::exception& e) {
7810       {
7811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7812       };
7813     } catch (...) {
7814       {
7815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7816       };
7817     }
7818   }
7819   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7820   return jresult;
7821 }
7822
7823
7824 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_2(void * jarg1, void * jarg2) {
7825   void * jresult ;
7826   Dali::Vector4 *arg1 = 0 ;
7827   Dali::Vector4 *arg2 = 0 ;
7828   Dali::Vector4 result;
7829
7830   arg1 = (Dali::Vector4 *)jarg1;
7831   if (!arg1) {
7832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7833     return 0;
7834   }
7835   arg2 = (Dali::Vector4 *)jarg2;
7836   if (!arg2) {
7837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7838     return 0;
7839   }
7840   {
7841     try {
7842       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7843     } catch (std::out_of_range& e) {
7844       {
7845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7846       };
7847     } catch (std::exception& e) {
7848       {
7849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7850       };
7851     } catch (...) {
7852       {
7853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7854       };
7855     }
7856   }
7857   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7858   return jresult;
7859 }
7860
7861
7862 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7863   void * jresult ;
7864   Dali::Vector4 *arg1 = 0 ;
7865   float *arg2 = 0 ;
7866   float *arg3 = 0 ;
7867   float temp2 ;
7868   float temp3 ;
7869   Dali::Vector4 result;
7870
7871   arg1 = (Dali::Vector4 *)jarg1;
7872   if (!arg1) {
7873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7874     return 0;
7875   }
7876   temp2 = (float)jarg2;
7877   arg2 = &temp2;
7878   temp3 = (float)jarg3;
7879   arg3 = &temp3;
7880   {
7881     try {
7882       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7883     } catch (std::out_of_range& e) {
7884       {
7885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7886       };
7887     } catch (std::exception& e) {
7888       {
7889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (...) {
7892       {
7893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7894       };
7895     }
7896   }
7897   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7898   return jresult;
7899 }
7900
7901
7902 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_0() {
7903   void * jresult ;
7904   Dali::Uint16Pair *result = 0 ;
7905
7906   {
7907     try {
7908       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7909     } catch (std::out_of_range& e) {
7910       {
7911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7912       };
7913     } catch (std::exception& e) {
7914       {
7915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7916       };
7917     } catch (...) {
7918       {
7919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7920       };
7921     }
7922   }
7923   jresult = (void *)result;
7924   return jresult;
7925 }
7926
7927
7928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
7929   void * jresult ;
7930   uint32_t arg1 ;
7931   uint32_t arg2 ;
7932   Dali::Uint16Pair *result = 0 ;
7933
7934   arg1 = (uint32_t)jarg1;
7935   arg2 = (uint32_t)jarg2;
7936   {
7937     try {
7938       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
7939     } catch (std::out_of_range& e) {
7940       {
7941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7942       };
7943     } catch (std::exception& e) {
7944       {
7945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7946       };
7947     } catch (...) {
7948       {
7949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7950       };
7951     }
7952   }
7953   jresult = (void *)result;
7954   return jresult;
7955 }
7956
7957
7958 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_2(void * jarg1) {
7959   void * jresult ;
7960   Dali::Uint16Pair *arg1 = 0 ;
7961   Dali::Uint16Pair *result = 0 ;
7962
7963   arg1 = (Dali::Uint16Pair *)jarg1;
7964   if (!arg1) {
7965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7966     return 0;
7967   }
7968   {
7969     try {
7970       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
7971     } catch (std::out_of_range& e) {
7972       {
7973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (std::exception& e) {
7976       {
7977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985   jresult = (void *)result;
7986   return jresult;
7987 }
7988
7989
7990 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
7991   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7992   uint16_t arg2 ;
7993
7994   arg1 = (Dali::Uint16Pair *)jarg1;
7995   arg2 = (uint16_t)jarg2;
7996   {
7997     try {
7998       (arg1)->SetWidth(arg2);
7999     } catch (std::out_of_range& e) {
8000       {
8001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8002       };
8003     } catch (std::exception& e) {
8004       {
8005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8006       };
8007     } catch (...) {
8008       {
8009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8010       };
8011     }
8012   }
8013 }
8014
8015
8016 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetWidth(void * jarg1) {
8017   unsigned short jresult ;
8018   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8019   uint16_t result;
8020
8021   arg1 = (Dali::Uint16Pair *)jarg1;
8022   {
8023     try {
8024       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8025     } catch (std::out_of_range& e) {
8026       {
8027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8028       };
8029     } catch (std::exception& e) {
8030       {
8031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8032       };
8033     } catch (...) {
8034       {
8035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8036       };
8037     }
8038   }
8039   jresult = result;
8040   return jresult;
8041 }
8042
8043
8044 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8045   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8046   uint16_t arg2 ;
8047
8048   arg1 = (Dali::Uint16Pair *)jarg1;
8049   arg2 = (uint16_t)jarg2;
8050   {
8051     try {
8052       (arg1)->SetHeight(arg2);
8053     } catch (std::out_of_range& e) {
8054       {
8055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8056       };
8057     } catch (std::exception& e) {
8058       {
8059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8060       };
8061     } catch (...) {
8062       {
8063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8064       };
8065     }
8066   }
8067 }
8068
8069
8070 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetHeight(void * jarg1) {
8071   unsigned short jresult ;
8072   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8073   uint16_t result;
8074
8075   arg1 = (Dali::Uint16Pair *)jarg1;
8076   {
8077     try {
8078       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8079     } catch (std::out_of_range& e) {
8080       {
8081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8082       };
8083     } catch (std::exception& e) {
8084       {
8085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8086       };
8087     } catch (...) {
8088       {
8089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8090       };
8091     }
8092   }
8093   jresult = result;
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8099   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8100   uint16_t arg2 ;
8101
8102   arg1 = (Dali::Uint16Pair *)jarg1;
8103   arg2 = (uint16_t)jarg2;
8104   {
8105     try {
8106       (arg1)->SetX(arg2);
8107     } catch (std::out_of_range& e) {
8108       {
8109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8110       };
8111     } catch (std::exception& e) {
8112       {
8113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8114       };
8115     } catch (...) {
8116       {
8117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8118       };
8119     }
8120   }
8121 }
8122
8123
8124 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetX(void * jarg1) {
8125   unsigned short jresult ;
8126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8127   uint16_t result;
8128
8129   arg1 = (Dali::Uint16Pair *)jarg1;
8130   {
8131     try {
8132       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8133     } catch (std::out_of_range& e) {
8134       {
8135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8136       };
8137     } catch (std::exception& e) {
8138       {
8139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8140       };
8141     } catch (...) {
8142       {
8143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8144       };
8145     }
8146   }
8147   jresult = result;
8148   return jresult;
8149 }
8150
8151
8152 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8153   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8154   uint16_t arg2 ;
8155
8156   arg1 = (Dali::Uint16Pair *)jarg1;
8157   arg2 = (uint16_t)jarg2;
8158   {
8159     try {
8160       (arg1)->SetY(arg2);
8161     } catch (std::out_of_range& e) {
8162       {
8163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8164       };
8165     } catch (std::exception& e) {
8166       {
8167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8168       };
8169     } catch (...) {
8170       {
8171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8172       };
8173     }
8174   }
8175 }
8176
8177
8178 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetY(void * jarg1) {
8179   unsigned short jresult ;
8180   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8181   uint16_t result;
8182
8183   arg1 = (Dali::Uint16Pair *)jarg1;
8184   {
8185     try {
8186       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (...) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8198       };
8199     }
8200   }
8201   jresult = result;
8202   return jresult;
8203 }
8204
8205
8206 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8207   void * jresult ;
8208   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8209   Dali::Uint16Pair *arg2 = 0 ;
8210   Dali::Uint16Pair *result = 0 ;
8211
8212   arg1 = (Dali::Uint16Pair *)jarg1;
8213   arg2 = (Dali::Uint16Pair *)jarg2;
8214   if (!arg2) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8216     return 0;
8217   }
8218   {
8219     try {
8220       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8221     } catch (std::out_of_range& e) {
8222       {
8223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8224       };
8225     } catch (std::exception& e) {
8226       {
8227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8228       };
8229     } catch (...) {
8230       {
8231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8232       };
8233     }
8234   }
8235   jresult = (void *)result;
8236   return jresult;
8237 }
8238
8239
8240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8241   unsigned int jresult ;
8242   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8243   Dali::Uint16Pair *arg2 = 0 ;
8244   bool result;
8245
8246   arg1 = (Dali::Uint16Pair *)jarg1;
8247   arg2 = (Dali::Uint16Pair *)jarg2;
8248   if (!arg2) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8250     return 0;
8251   }
8252   {
8253     try {
8254       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8255     } catch (std::out_of_range& e) {
8256       {
8257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8258       };
8259     } catch (std::exception& e) {
8260       {
8261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (...) {
8264       {
8265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8266       };
8267     }
8268   }
8269   jresult = result;
8270   return jresult;
8271 }
8272
8273
8274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8275   unsigned int jresult ;
8276   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8277   Dali::Uint16Pair *arg2 = 0 ;
8278   bool result;
8279
8280   arg1 = (Dali::Uint16Pair *)jarg1;
8281   arg2 = (Dali::Uint16Pair *)jarg2;
8282   if (!arg2) {
8283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8284     return 0;
8285   }
8286   {
8287     try {
8288       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8289     } catch (std::out_of_range& e) {
8290       {
8291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8292       };
8293     } catch (std::exception& e) {
8294       {
8295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8296       };
8297     } catch (...) {
8298       {
8299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8300       };
8301     }
8302   }
8303   jresult = result;
8304   return jresult;
8305 }
8306
8307
8308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8309   unsigned int jresult ;
8310   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8311   Dali::Uint16Pair *arg2 = 0 ;
8312   bool result;
8313
8314   arg1 = (Dali::Uint16Pair *)jarg1;
8315   arg2 = (Dali::Uint16Pair *)jarg2;
8316   if (!arg2) {
8317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8318     return 0;
8319   }
8320   {
8321     try {
8322       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8323     } catch (std::out_of_range& e) {
8324       {
8325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8326       };
8327     } catch (std::exception& e) {
8328       {
8329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8330       };
8331     } catch (...) {
8332       {
8333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8334       };
8335     }
8336   }
8337   jresult = result;
8338   return jresult;
8339 }
8340
8341
8342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8343   unsigned int jresult ;
8344   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8345   Dali::Uint16Pair *arg2 = 0 ;
8346   bool result;
8347
8348   arg1 = (Dali::Uint16Pair *)jarg1;
8349   arg2 = (Dali::Uint16Pair *)jarg2;
8350   if (!arg2) {
8351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8352     return 0;
8353   }
8354   {
8355     try {
8356       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8357     } catch (std::out_of_range& e) {
8358       {
8359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8360       };
8361     } catch (std::exception& e) {
8362       {
8363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8364       };
8365     } catch (...) {
8366       {
8367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8368       };
8369     }
8370   }
8371   jresult = result;
8372   return jresult;
8373 }
8374
8375
8376 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Uint16Pair(void * jarg1) {
8377   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8378
8379   arg1 = (Dali::Uint16Pair *)jarg1;
8380   {
8381     try {
8382       delete arg1;
8383     } catch (std::out_of_range& e) {
8384       {
8385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8386       };
8387     } catch (std::exception& e) {
8388       {
8389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8390       };
8391     } catch (...) {
8392       {
8393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8394       };
8395     }
8396   }
8397 }
8398
8399
8400 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_0() {
8401   void * jresult ;
8402   Dali::Degree *result = 0 ;
8403
8404   {
8405     try {
8406       result = (Dali::Degree *)new Dali::Degree();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8414       };
8415     } catch (...) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8418       };
8419     }
8420   }
8421   jresult = (void *)result;
8422   return jresult;
8423 }
8424
8425
8426 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_1(float jarg1) {
8427   void * jresult ;
8428   float arg1 ;
8429   Dali::Degree *result = 0 ;
8430
8431   arg1 = (float)jarg1;
8432   {
8433     try {
8434       result = (Dali::Degree *)new Dali::Degree(arg1);
8435     } catch (std::out_of_range& e) {
8436       {
8437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8438       };
8439     } catch (std::exception& e) {
8440       {
8441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8442       };
8443     } catch (...) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8446       };
8447     }
8448   }
8449   jresult = (void *)result;
8450   return jresult;
8451 }
8452
8453
8454 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_2(void * jarg1) {
8455   void * jresult ;
8456   Dali::Radian arg1 ;
8457   Dali::Radian *argp1 ;
8458   Dali::Degree *result = 0 ;
8459
8460   argp1 = (Dali::Radian *)jarg1;
8461   if (!argp1) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8463     return 0;
8464   }
8465   arg1 = *argp1;
8466   {
8467     try {
8468       result = (Dali::Degree *)new Dali::Degree(arg1);
8469     } catch (std::out_of_range& e) {
8470       {
8471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8472       };
8473     } catch (std::exception& e) {
8474       {
8475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8480       };
8481     }
8482   }
8483   jresult = (void *)result;
8484   return jresult;
8485 }
8486
8487
8488 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Degree_degree_set(void * jarg1, float jarg2) {
8489   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8490   float arg2 ;
8491
8492   arg1 = (Dali::Degree *)jarg1;
8493   arg2 = (float)jarg2;
8494   if (arg1) (arg1)->degree = arg2;
8495 }
8496
8497
8498 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Degree_degree_get(void * jarg1) {
8499   float jresult ;
8500   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8501   float result;
8502
8503   arg1 = (Dali::Degree *)jarg1;
8504   result = (float) ((arg1)->degree);
8505   jresult = result;
8506   return jresult;
8507 }
8508
8509
8510 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Degree(void * jarg1) {
8511   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8512
8513   arg1 = (Dali::Degree *)jarg1;
8514   {
8515     try {
8516       delete arg1;
8517     } catch (std::out_of_range& e) {
8518       {
8519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8520       };
8521     } catch (std::exception& e) {
8522       {
8523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8524       };
8525     } catch (...) {
8526       {
8527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8528       };
8529     }
8530   }
8531 }
8532
8533
8534 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_360_get() {
8535   void * jresult ;
8536   Dali::Radian *result = 0 ;
8537
8538   result = (Dali::Radian *)&Dali::ANGLE_360;
8539   jresult = (void *)result;
8540   return jresult;
8541 }
8542
8543
8544 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_315_get() {
8545   void * jresult ;
8546   Dali::Radian *result = 0 ;
8547
8548   result = (Dali::Radian *)&Dali::ANGLE_315;
8549   jresult = (void *)result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_270_get() {
8555   void * jresult ;
8556   Dali::Radian *result = 0 ;
8557
8558   result = (Dali::Radian *)&Dali::ANGLE_270;
8559   jresult = (void *)result;
8560   return jresult;
8561 }
8562
8563
8564 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_225_get() {
8565   void * jresult ;
8566   Dali::Radian *result = 0 ;
8567
8568   result = (Dali::Radian *)&Dali::ANGLE_225;
8569   jresult = (void *)result;
8570   return jresult;
8571 }
8572
8573
8574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_180_get() {
8575   void * jresult ;
8576   Dali::Radian *result = 0 ;
8577
8578   result = (Dali::Radian *)&Dali::ANGLE_180;
8579   jresult = (void *)result;
8580   return jresult;
8581 }
8582
8583
8584 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_135_get() {
8585   void * jresult ;
8586   Dali::Radian *result = 0 ;
8587
8588   result = (Dali::Radian *)&Dali::ANGLE_135;
8589   jresult = (void *)result;
8590   return jresult;
8591 }
8592
8593
8594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_120_get() {
8595   void * jresult ;
8596   Dali::Radian *result = 0 ;
8597
8598   result = (Dali::Radian *)&Dali::ANGLE_120;
8599   jresult = (void *)result;
8600   return jresult;
8601 }
8602
8603
8604 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_90_get() {
8605   void * jresult ;
8606   Dali::Radian *result = 0 ;
8607
8608   result = (Dali::Radian *)&Dali::ANGLE_90;
8609   jresult = (void *)result;
8610   return jresult;
8611 }
8612
8613
8614 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_60_get() {
8615   void * jresult ;
8616   Dali::Radian *result = 0 ;
8617
8618   result = (Dali::Radian *)&Dali::ANGLE_60;
8619   jresult = (void *)result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_45_get() {
8625   void * jresult ;
8626   Dali::Radian *result = 0 ;
8627
8628   result = (Dali::Radian *)&Dali::ANGLE_45;
8629   jresult = (void *)result;
8630   return jresult;
8631 }
8632
8633
8634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_30_get() {
8635   void * jresult ;
8636   Dali::Radian *result = 0 ;
8637
8638   result = (Dali::Radian *)&Dali::ANGLE_30;
8639   jresult = (void *)result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_0_get() {
8645   void * jresult ;
8646   Dali::Radian *result = 0 ;
8647
8648   result = (Dali::Radian *)&Dali::ANGLE_0;
8649   jresult = (void *)result;
8650   return jresult;
8651 }
8652
8653
8654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8655   unsigned int jresult ;
8656   Dali::Degree *arg1 = 0 ;
8657   Dali::Degree *arg2 = 0 ;
8658   bool result;
8659
8660   arg1 = (Dali::Degree *)jarg1;
8661   if (!arg1) {
8662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8663     return 0;
8664   }
8665   arg2 = (Dali::Degree *)jarg2;
8666   if (!arg2) {
8667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8668     return 0;
8669   }
8670   {
8671     try {
8672       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8673     } catch (std::out_of_range& e) {
8674       {
8675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8676       };
8677     } catch (std::exception& e) {
8678       {
8679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8680       };
8681     } catch (...) {
8682       {
8683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8684       };
8685     }
8686   }
8687   jresult = result;
8688   return jresult;
8689 }
8690
8691
8692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8693   unsigned int jresult ;
8694   Dali::Degree *arg1 = 0 ;
8695   Dali::Degree *arg2 = 0 ;
8696   bool result;
8697
8698   arg1 = (Dali::Degree *)jarg1;
8699   if (!arg1) {
8700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8701     return 0;
8702   }
8703   arg2 = (Dali::Degree *)jarg2;
8704   if (!arg2) {
8705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8706     return 0;
8707   }
8708   {
8709     try {
8710       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8711     } catch (std::out_of_range& e) {
8712       {
8713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8714       };
8715     } catch (std::exception& e) {
8716       {
8717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8718       };
8719     } catch (...) {
8720       {
8721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8722       };
8723     }
8724   }
8725   jresult = result;
8726   return jresult;
8727 }
8728
8729
8730 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8731   void * jresult ;
8732   Dali::Degree arg1 ;
8733   float arg2 ;
8734   float arg3 ;
8735   Dali::Degree *argp1 ;
8736   Dali::Degree result;
8737
8738   argp1 = (Dali::Degree *)jarg1;
8739   if (!argp1) {
8740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8741     return 0;
8742   }
8743   arg1 = *argp1;
8744   arg2 = (float)jarg2;
8745   arg3 = (float)jarg3;
8746   {
8747     try {
8748       result = Dali::Clamp(arg1,arg2,arg3);
8749     } catch (std::out_of_range& e) {
8750       {
8751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8752       };
8753     } catch (std::exception& e) {
8754       {
8755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8756       };
8757     } catch (...) {
8758       {
8759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8760       };
8761     }
8762   }
8763   jresult = new Dali::Degree((const Dali::Degree &)result);
8764   return jresult;
8765 }
8766
8767
8768 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_0() {
8769   void * jresult ;
8770   Dali::Radian *result = 0 ;
8771
8772   {
8773     try {
8774       result = (Dali::Radian *)new Dali::Radian();
8775     } catch (std::out_of_range& e) {
8776       {
8777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8778       };
8779     } catch (std::exception& e) {
8780       {
8781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8782       };
8783     } catch (...) {
8784       {
8785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8786       };
8787     }
8788   }
8789   jresult = (void *)result;
8790   return jresult;
8791 }
8792
8793
8794 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_1(float jarg1) {
8795   void * jresult ;
8796   float arg1 ;
8797   Dali::Radian *result = 0 ;
8798
8799   arg1 = (float)jarg1;
8800   {
8801     try {
8802       result = (Dali::Radian *)new Dali::Radian(arg1);
8803     } catch (std::out_of_range& e) {
8804       {
8805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8806       };
8807     } catch (std::exception& e) {
8808       {
8809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8810       };
8811     } catch (...) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8814       };
8815     }
8816   }
8817   jresult = (void *)result;
8818   return jresult;
8819 }
8820
8821
8822 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_2(void * jarg1) {
8823   void * jresult ;
8824   Dali::Degree arg1 ;
8825   Dali::Degree *argp1 ;
8826   Dali::Radian *result = 0 ;
8827
8828   argp1 = (Dali::Degree *)jarg1;
8829   if (!argp1) {
8830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8831     return 0;
8832   }
8833   arg1 = *argp1;
8834   {
8835     try {
8836       result = (Dali::Radian *)new Dali::Radian(arg1);
8837     } catch (std::out_of_range& e) {
8838       {
8839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8840       };
8841     } catch (std::exception& e) {
8842       {
8843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8844       };
8845     } catch (...) {
8846       {
8847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8848       };
8849     }
8850   }
8851   jresult = (void *)result;
8852   return jresult;
8853 }
8854
8855
8856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8857   void * jresult ;
8858   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8859   float arg2 ;
8860   Dali::Radian *result = 0 ;
8861
8862   arg1 = (Dali::Radian *)jarg1;
8863   arg2 = (float)jarg2;
8864   {
8865     try {
8866       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8867     } catch (std::out_of_range& e) {
8868       {
8869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8870       };
8871     } catch (std::exception& e) {
8872       {
8873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8874       };
8875     } catch (...) {
8876       {
8877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8878       };
8879     }
8880   }
8881   jresult = (void *)result;
8882   return jresult;
8883 }
8884
8885
8886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8887   void * jresult ;
8888   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8889   Dali::Degree arg2 ;
8890   Dali::Degree *argp2 ;
8891   Dali::Radian *result = 0 ;
8892
8893   arg1 = (Dali::Radian *)jarg1;
8894   argp2 = (Dali::Degree *)jarg2;
8895   if (!argp2) {
8896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8897     return 0;
8898   }
8899   arg2 = *argp2;
8900   {
8901     try {
8902       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8903     } catch (std::out_of_range& e) {
8904       {
8905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (std::exception& e) {
8908       {
8909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (...) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8914       };
8915     }
8916   }
8917   jresult = (void *)result;
8918   return jresult;
8919 }
8920
8921
8922 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Radian_ConvertToFloat(void * jarg1) {
8923   float jresult ;
8924   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8925   float result;
8926
8927   arg1 = (Dali::Radian *)jarg1;
8928   {
8929     try {
8930       result = (float)((Dali::Radian const *)arg1)->operator float();
8931     } catch (std::out_of_range& e) {
8932       {
8933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8934       };
8935     } catch (std::exception& e) {
8936       {
8937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (...) {
8940       {
8941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8942       };
8943     }
8944   }
8945   jresult = result;
8946   return jresult;
8947 }
8948
8949
8950 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Radian_radian_set(void * jarg1, float jarg2) {
8951   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8952   float arg2 ;
8953
8954   arg1 = (Dali::Radian *)jarg1;
8955   arg2 = (float)jarg2;
8956   if (arg1) (arg1)->radian = arg2;
8957 }
8958
8959
8960 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Radian_radian_get(void * jarg1) {
8961   float jresult ;
8962   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8963   float result;
8964
8965   arg1 = (Dali::Radian *)jarg1;
8966   result = (float) ((arg1)->radian);
8967   jresult = result;
8968   return jresult;
8969 }
8970
8971
8972 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Radian(void * jarg1) {
8973   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8974
8975   arg1 = (Dali::Radian *)jarg1;
8976   {
8977     try {
8978       delete arg1;
8979     } catch (std::out_of_range& e) {
8980       {
8981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8982       };
8983     } catch (std::exception& e) {
8984       {
8985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8986       };
8987     } catch (...) {
8988       {
8989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8990       };
8991     }
8992   }
8993 }
8994
8995
8996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
8997   unsigned int jresult ;
8998   Dali::Radian arg1 ;
8999   Dali::Radian arg2 ;
9000   Dali::Radian *argp1 ;
9001   Dali::Radian *argp2 ;
9002   bool result;
9003
9004   argp1 = (Dali::Radian *)jarg1;
9005   if (!argp1) {
9006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9007     return 0;
9008   }
9009   arg1 = *argp1;
9010   argp2 = (Dali::Radian *)jarg2;
9011   if (!argp2) {
9012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9013     return 0;
9014   }
9015   arg2 = *argp2;
9016   {
9017     try {
9018       result = (bool)Dali::operator ==(arg1,arg2);
9019     } catch (std::out_of_range& e) {
9020       {
9021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9022       };
9023     } catch (std::exception& e) {
9024       {
9025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9026       };
9027     } catch (...) {
9028       {
9029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9030       };
9031     }
9032   }
9033   jresult = result;
9034   return jresult;
9035 }
9036
9037
9038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9039   unsigned int jresult ;
9040   Dali::Radian arg1 ;
9041   Dali::Radian arg2 ;
9042   Dali::Radian *argp1 ;
9043   Dali::Radian *argp2 ;
9044   bool result;
9045
9046   argp1 = (Dali::Radian *)jarg1;
9047   if (!argp1) {
9048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9049     return 0;
9050   }
9051   arg1 = *argp1;
9052   argp2 = (Dali::Radian *)jarg2;
9053   if (!argp2) {
9054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9055     return 0;
9056   }
9057   arg2 = *argp2;
9058   {
9059     try {
9060       result = (bool)Dali::operator !=(arg1,arg2);
9061     } catch (std::out_of_range& e) {
9062       {
9063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9064       };
9065     } catch (std::exception& e) {
9066       {
9067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9068       };
9069     } catch (...) {
9070       {
9071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9072       };
9073     }
9074   }
9075   jresult = result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9081   unsigned int jresult ;
9082   Dali::Radian arg1 ;
9083   Dali::Degree arg2 ;
9084   Dali::Radian *argp1 ;
9085   Dali::Degree *argp2 ;
9086   bool result;
9087
9088   argp1 = (Dali::Radian *)jarg1;
9089   if (!argp1) {
9090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9091     return 0;
9092   }
9093   arg1 = *argp1;
9094   argp2 = (Dali::Degree *)jarg2;
9095   if (!argp2) {
9096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9097     return 0;
9098   }
9099   arg2 = *argp2;
9100   {
9101     try {
9102       result = (bool)Dali::operator ==(arg1,arg2);
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (...) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9114       };
9115     }
9116   }
9117   jresult = result;
9118   return jresult;
9119 }
9120
9121
9122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9123   unsigned int jresult ;
9124   Dali::Radian arg1 ;
9125   Dali::Degree arg2 ;
9126   Dali::Radian *argp1 ;
9127   Dali::Degree *argp2 ;
9128   bool result;
9129
9130   argp1 = (Dali::Radian *)jarg1;
9131   if (!argp1) {
9132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9133     return 0;
9134   }
9135   arg1 = *argp1;
9136   argp2 = (Dali::Degree *)jarg2;
9137   if (!argp2) {
9138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9139     return 0;
9140   }
9141   arg2 = *argp2;
9142   {
9143     try {
9144       result = (bool)Dali::operator !=(arg1,arg2);
9145     } catch (std::out_of_range& e) {
9146       {
9147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9148       };
9149     } catch (std::exception& e) {
9150       {
9151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9152       };
9153     } catch (...) {
9154       {
9155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9156       };
9157     }
9158   }
9159   jresult = result;
9160   return jresult;
9161 }
9162
9163
9164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9165   unsigned int jresult ;
9166   Dali::Degree arg1 ;
9167   Dali::Radian arg2 ;
9168   Dali::Degree *argp1 ;
9169   Dali::Radian *argp2 ;
9170   bool result;
9171
9172   argp1 = (Dali::Degree *)jarg1;
9173   if (!argp1) {
9174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9175     return 0;
9176   }
9177   arg1 = *argp1;
9178   argp2 = (Dali::Radian *)jarg2;
9179   if (!argp2) {
9180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9181     return 0;
9182   }
9183   arg2 = *argp2;
9184   {
9185     try {
9186       result = (bool)Dali::operator ==(arg1,arg2);
9187     } catch (std::out_of_range& e) {
9188       {
9189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9190       };
9191     } catch (std::exception& e) {
9192       {
9193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9194       };
9195     } catch (...) {
9196       {
9197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9198       };
9199     }
9200   }
9201   jresult = result;
9202   return jresult;
9203 }
9204
9205
9206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9207   unsigned int jresult ;
9208   Dali::Degree arg1 ;
9209   Dali::Radian arg2 ;
9210   Dali::Degree *argp1 ;
9211   Dali::Radian *argp2 ;
9212   bool result;
9213
9214   argp1 = (Dali::Degree *)jarg1;
9215   if (!argp1) {
9216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9217     return 0;
9218   }
9219   arg1 = *argp1;
9220   argp2 = (Dali::Radian *)jarg2;
9221   if (!argp2) {
9222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9223     return 0;
9224   }
9225   arg2 = *argp2;
9226   {
9227     try {
9228       result = (bool)Dali::operator !=(arg1,arg2);
9229     } catch (std::out_of_range& e) {
9230       {
9231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (std::exception& e) {
9234       {
9235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (...) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9240       };
9241     }
9242   }
9243   jresult = result;
9244   return jresult;
9245 }
9246
9247
9248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9249   unsigned int jresult ;
9250   Dali::Radian arg1 ;
9251   Dali::Radian arg2 ;
9252   Dali::Radian *argp1 ;
9253   Dali::Radian *argp2 ;
9254   bool result;
9255
9256   argp1 = (Dali::Radian *)jarg1;
9257   if (!argp1) {
9258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9259     return 0;
9260   }
9261   arg1 = *argp1;
9262   argp2 = (Dali::Radian *)jarg2;
9263   if (!argp2) {
9264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9265     return 0;
9266   }
9267   arg2 = *argp2;
9268   {
9269     try {
9270       result = (bool)Dali::operator >(arg1,arg2);
9271     } catch (std::out_of_range& e) {
9272       {
9273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9274       };
9275     } catch (std::exception& e) {
9276       {
9277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9278       };
9279     } catch (...) {
9280       {
9281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9282       };
9283     }
9284   }
9285   jresult = result;
9286   return jresult;
9287 }
9288
9289
9290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9291   unsigned int jresult ;
9292   Dali::Radian arg1 ;
9293   Dali::Degree arg2 ;
9294   Dali::Radian *argp1 ;
9295   Dali::Degree *argp2 ;
9296   bool result;
9297
9298   argp1 = (Dali::Radian *)jarg1;
9299   if (!argp1) {
9300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9301     return 0;
9302   }
9303   arg1 = *argp1;
9304   argp2 = (Dali::Degree *)jarg2;
9305   if (!argp2) {
9306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9307     return 0;
9308   }
9309   arg2 = *argp2;
9310   {
9311     try {
9312       result = (bool)Dali::operator >(arg1,arg2);
9313     } catch (std::out_of_range& e) {
9314       {
9315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9316       };
9317     } catch (std::exception& e) {
9318       {
9319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9320       };
9321     } catch (...) {
9322       {
9323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9324       };
9325     }
9326   }
9327   jresult = result;
9328   return jresult;
9329 }
9330
9331
9332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9333   unsigned int jresult ;
9334   Dali::Degree arg1 ;
9335   Dali::Radian arg2 ;
9336   Dali::Degree *argp1 ;
9337   Dali::Radian *argp2 ;
9338   bool result;
9339
9340   argp1 = (Dali::Degree *)jarg1;
9341   if (!argp1) {
9342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9343     return 0;
9344   }
9345   arg1 = *argp1;
9346   argp2 = (Dali::Radian *)jarg2;
9347   if (!argp2) {
9348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9349     return 0;
9350   }
9351   arg2 = *argp2;
9352   {
9353     try {
9354       result = (bool)Dali::operator >(arg1,arg2);
9355     } catch (std::out_of_range& e) {
9356       {
9357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9358       };
9359     } catch (std::exception& e) {
9360       {
9361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9362       };
9363     } catch (...) {
9364       {
9365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9366       };
9367     }
9368   }
9369   jresult = result;
9370   return jresult;
9371 }
9372
9373
9374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9375   unsigned int jresult ;
9376   Dali::Radian arg1 ;
9377   Dali::Radian arg2 ;
9378   Dali::Radian *argp1 ;
9379   Dali::Radian *argp2 ;
9380   bool result;
9381
9382   argp1 = (Dali::Radian *)jarg1;
9383   if (!argp1) {
9384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9385     return 0;
9386   }
9387   arg1 = *argp1;
9388   argp2 = (Dali::Radian *)jarg2;
9389   if (!argp2) {
9390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9391     return 0;
9392   }
9393   arg2 = *argp2;
9394   {
9395     try {
9396       result = (bool)Dali::operator <(arg1,arg2);
9397     } catch (std::out_of_range& e) {
9398       {
9399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9400       };
9401     } catch (std::exception& e) {
9402       {
9403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9404       };
9405     } catch (...) {
9406       {
9407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9408       };
9409     }
9410   }
9411   jresult = result;
9412   return jresult;
9413 }
9414
9415
9416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9417   unsigned int jresult ;
9418   Dali::Radian arg1 ;
9419   Dali::Degree arg2 ;
9420   Dali::Radian *argp1 ;
9421   Dali::Degree *argp2 ;
9422   bool result;
9423
9424   argp1 = (Dali::Radian *)jarg1;
9425   if (!argp1) {
9426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9427     return 0;
9428   }
9429   arg1 = *argp1;
9430   argp2 = (Dali::Degree *)jarg2;
9431   if (!argp2) {
9432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9433     return 0;
9434   }
9435   arg2 = *argp2;
9436   {
9437     try {
9438       result = (bool)Dali::operator <(arg1,arg2);
9439     } catch (std::out_of_range& e) {
9440       {
9441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (std::exception& e) {
9444       {
9445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (...) {
9448       {
9449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9450       };
9451     }
9452   }
9453   jresult = result;
9454   return jresult;
9455 }
9456
9457
9458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9459   unsigned int jresult ;
9460   Dali::Degree arg1 ;
9461   Dali::Radian arg2 ;
9462   Dali::Degree *argp1 ;
9463   Dali::Radian *argp2 ;
9464   bool result;
9465
9466   argp1 = (Dali::Degree *)jarg1;
9467   if (!argp1) {
9468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9469     return 0;
9470   }
9471   arg1 = *argp1;
9472   argp2 = (Dali::Radian *)jarg2;
9473   if (!argp2) {
9474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9475     return 0;
9476   }
9477   arg2 = *argp2;
9478   {
9479     try {
9480       result = (bool)Dali::operator <(arg1,arg2);
9481     } catch (std::out_of_range& e) {
9482       {
9483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9484       };
9485     } catch (std::exception& e) {
9486       {
9487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9488       };
9489     } catch (...) {
9490       {
9491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9492       };
9493     }
9494   }
9495   jresult = result;
9496   return jresult;
9497 }
9498
9499
9500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Multiply(void * jarg1, float jarg2) {
9501   void * jresult ;
9502   Dali::Radian arg1 ;
9503   float arg2 ;
9504   Dali::Radian *argp1 ;
9505   Dali::Radian result;
9506
9507   argp1 = (Dali::Radian *)jarg1;
9508   if (!argp1) {
9509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9510     return 0;
9511   }
9512   arg1 = *argp1;
9513   arg2 = (float)jarg2;
9514   {
9515     try {
9516       result = Dali::operator *(arg1,arg2);
9517     } catch (std::out_of_range& e) {
9518       {
9519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9520       };
9521     } catch (std::exception& e) {
9522       {
9523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9524       };
9525     } catch (...) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9528       };
9529     }
9530   }
9531   jresult = new Dali::Radian((const Dali::Radian &)result);
9532   return jresult;
9533 }
9534
9535
9536 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Subtract(void * jarg1) {
9537   void * jresult ;
9538   Dali::Radian arg1 ;
9539   Dali::Radian *argp1 ;
9540   Dali::Radian result;
9541
9542   argp1 = (Dali::Radian *)jarg1;
9543   if (!argp1) {
9544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9545     return 0;
9546   }
9547   arg1 = *argp1;
9548   {
9549     try {
9550       result = Dali::operator -(arg1);
9551     } catch (std::out_of_range& e) {
9552       {
9553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (std::exception& e) {
9556       {
9557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9558       };
9559     } catch (...) {
9560       {
9561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9562       };
9563     }
9564   }
9565   jresult = new Dali::Radian((const Dali::Radian &)result);
9566   return jresult;
9567 }
9568
9569
9570 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9571   void * jresult ;
9572   Dali::Radian arg1 ;
9573   float arg2 ;
9574   float arg3 ;
9575   Dali::Radian *argp1 ;
9576   Dali::Radian result;
9577
9578   argp1 = (Dali::Radian *)jarg1;
9579   if (!argp1) {
9580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9581     return 0;
9582   }
9583   arg1 = *argp1;
9584   arg2 = (float)jarg2;
9585   arg3 = (float)jarg3;
9586   {
9587     try {
9588       result = Dali::Clamp(arg1,arg2,arg3);
9589     } catch (std::out_of_range& e) {
9590       {
9591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9592       };
9593     } catch (std::exception& e) {
9594       {
9595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9596       };
9597     } catch (...) {
9598       {
9599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9600       };
9601     }
9602   }
9603   jresult = new Dali::Radian((const Dali::Radian &)result);
9604   return jresult;
9605 }
9606
9607
9608 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_0() {
9609   void * jresult ;
9610   Dali::Quaternion *result = 0 ;
9611
9612   {
9613     try {
9614       result = (Dali::Quaternion *)new Dali::Quaternion();
9615     } catch (std::out_of_range& e) {
9616       {
9617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9618       };
9619     } catch (std::exception& e) {
9620       {
9621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (...) {
9624       {
9625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9626       };
9627     }
9628   }
9629   jresult = (void *)result;
9630   return jresult;
9631 }
9632
9633
9634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
9635   void * jresult ;
9636   float arg1 ;
9637   float arg2 ;
9638   float arg3 ;
9639   float arg4 ;
9640   Dali::Quaternion *result = 0 ;
9641
9642   arg1 = (float)jarg1;
9643   arg2 = (float)jarg2;
9644   arg3 = (float)jarg3;
9645   arg4 = (float)jarg4;
9646   {
9647     try {
9648       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3,arg4);
9649     } catch (std::out_of_range& e) {
9650       {
9651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9652       };
9653     } catch (std::exception& e) {
9654       {
9655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9656       };
9657     } catch (...) {
9658       {
9659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9660       };
9661     }
9662   }
9663   jresult = (void *)result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_2(void * jarg1) {
9669   void * jresult ;
9670   Dali::Vector4 *arg1 = 0 ;
9671   Dali::Quaternion *result = 0 ;
9672
9673   arg1 = (Dali::Vector4 *)jarg1;
9674   if (!arg1) {
9675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
9676     return 0;
9677   }
9678   {
9679     try {
9680       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector4 const &)*arg1);
9681     } catch (std::out_of_range& e) {
9682       {
9683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9684       };
9685     } catch (std::exception& e) {
9686       {
9687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9688       };
9689     } catch (...) {
9690       {
9691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9692       };
9693     }
9694   }
9695   jresult = (void *)result;
9696   return jresult;
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_3(void * jarg1, void * jarg2) {
9701   void * jresult ;
9702   Dali::Radian arg1 ;
9703   Dali::Vector3 *arg2 = 0 ;
9704   Dali::Radian *argp1 ;
9705   Dali::Quaternion *result = 0 ;
9706
9707   argp1 = (Dali::Radian *)jarg1;
9708   if (!argp1) {
9709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9710     return 0;
9711   }
9712   arg1 = *argp1;
9713   arg2 = (Dali::Vector3 *)jarg2;
9714   if (!arg2) {
9715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9716     return 0;
9717   }
9718   {
9719     try {
9720       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9721     } catch (std::out_of_range& e) {
9722       {
9723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9724       };
9725     } catch (std::exception& e) {
9726       {
9727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9728       };
9729     } catch (...) {
9730       {
9731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9732       };
9733     }
9734   }
9735   jresult = (void *)result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
9741   void * jresult ;
9742   Dali::Radian arg1 ;
9743   Dali::Radian arg2 ;
9744   Dali::Radian arg3 ;
9745   Dali::Radian *argp1 ;
9746   Dali::Radian *argp2 ;
9747   Dali::Radian *argp3 ;
9748   Dali::Quaternion *result = 0 ;
9749
9750   argp1 = (Dali::Radian *)jarg1;
9751   if (!argp1) {
9752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9753     return 0;
9754   }
9755   arg1 = *argp1;
9756   argp2 = (Dali::Radian *)jarg2;
9757   if (!argp2) {
9758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9759     return 0;
9760   }
9761   arg2 = *argp2;
9762   argp3 = (Dali::Radian *)jarg3;
9763   if (!argp3) {
9764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9765     return 0;
9766   }
9767   arg3 = *argp3;
9768   {
9769     try {
9770       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3);
9771     } catch (std::out_of_range& e) {
9772       {
9773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9774       };
9775     } catch (std::exception& e) {
9776       {
9777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9778       };
9779     } catch (...) {
9780       {
9781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9782       };
9783     }
9784   }
9785   jresult = (void *)result;
9786   return jresult;
9787 }
9788
9789
9790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_5(void * jarg1) {
9791   void * jresult ;
9792   Dali::Matrix *arg1 = 0 ;
9793   Dali::Quaternion *result = 0 ;
9794
9795   arg1 = (Dali::Matrix *)jarg1;
9796   if (!arg1) {
9797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9798     return 0;
9799   }
9800   {
9801     try {
9802       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Matrix const &)*arg1);
9803     } catch (std::out_of_range& e) {
9804       {
9805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9806       };
9807     } catch (std::exception& e) {
9808       {
9809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9810       };
9811     } catch (...) {
9812       {
9813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9814       };
9815     }
9816   }
9817   jresult = (void *)result;
9818   return jresult;
9819 }
9820
9821
9822 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
9823   void * jresult ;
9824   Dali::Vector3 *arg1 = 0 ;
9825   Dali::Vector3 *arg2 = 0 ;
9826   Dali::Vector3 *arg3 = 0 ;
9827   Dali::Quaternion *result = 0 ;
9828
9829   arg1 = (Dali::Vector3 *)jarg1;
9830   if (!arg1) {
9831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9832     return 0;
9833   }
9834   arg2 = (Dali::Vector3 *)jarg2;
9835   if (!arg2) {
9836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9837     return 0;
9838   }
9839   arg3 = (Dali::Vector3 *)jarg3;
9840   if (!arg3) {
9841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9842     return 0;
9843   }
9844   {
9845     try {
9846       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
9847     } catch (std::out_of_range& e) {
9848       {
9849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9850       };
9851     } catch (std::exception& e) {
9852       {
9853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9854       };
9855     } catch (...) {
9856       {
9857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9858       };
9859     }
9860   }
9861   jresult = (void *)result;
9862   return jresult;
9863 }
9864
9865
9866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_7(void * jarg1, void * jarg2) {
9867   void * jresult ;
9868   Dali::Vector3 *arg1 = 0 ;
9869   Dali::Vector3 *arg2 = 0 ;
9870   Dali::Quaternion *result = 0 ;
9871
9872   arg1 = (Dali::Vector3 *)jarg1;
9873   if (!arg1) {
9874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9875     return 0;
9876   }
9877   arg2 = (Dali::Vector3 *)jarg2;
9878   if (!arg2) {
9879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9880     return 0;
9881   }
9882   {
9883     try {
9884       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
9885     } catch (std::out_of_range& e) {
9886       {
9887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9888       };
9889     } catch (std::exception& e) {
9890       {
9891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (...) {
9894       {
9895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9896       };
9897     }
9898   }
9899   jresult = (void *)result;
9900   return jresult;
9901 }
9902
9903
9904 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Quaternion(void * jarg1) {
9905   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9906
9907   arg1 = (Dali::Quaternion *)jarg1;
9908   {
9909     try {
9910       delete arg1;
9911     } catch (std::out_of_range& e) {
9912       {
9913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9914       };
9915     } catch (std::exception& e) {
9916       {
9917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9918       };
9919     } catch (...) {
9920       {
9921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9922       };
9923     }
9924   }
9925 }
9926
9927
9928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_IDENTITY_get() {
9929   void * jresult ;
9930   Dali::Quaternion *result = 0 ;
9931
9932   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9933   jresult = (void *)result;
9934   return jresult;
9935 }
9936
9937
9938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_IsIdentity(void * jarg1) {
9939   unsigned int jresult ;
9940   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9941   bool result;
9942
9943   arg1 = (Dali::Quaternion *)jarg1;
9944   {
9945     try {
9946       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9947     } catch (std::out_of_range& e) {
9948       {
9949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9950       };
9951     } catch (std::exception& e) {
9952       {
9953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (...) {
9956       {
9957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9958       };
9959     }
9960   }
9961   jresult = result;
9962   return jresult;
9963 }
9964
9965
9966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_ToAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9967   unsigned int jresult ;
9968   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9969   Dali::Vector3 *arg2 = 0 ;
9970   Dali::Radian *arg3 = 0 ;
9971   bool result;
9972
9973   arg1 = (Dali::Quaternion *)jarg1;
9974   arg2 = (Dali::Vector3 *)jarg2;
9975   if (!arg2) {
9976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9977     return 0;
9978   }
9979   arg3 = (Dali::Radian *)jarg3;
9980   if (!arg3) {
9981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9982     return 0;
9983   }
9984   {
9985     try {
9986       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9987     } catch (std::out_of_range& e) {
9988       {
9989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (std::exception& e) {
9992       {
9993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (...) {
9996       {
9997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9998       };
9999     }
10000   }
10001   jresult = result;
10002   return jresult;
10003 }
10004
10005
10006 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_AsVector(void * jarg1) {
10007   void * jresult ;
10008   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10009   Dali::Vector4 *result = 0 ;
10010
10011   arg1 = (Dali::Quaternion *)jarg1;
10012   {
10013     try {
10014       result = (Dali::Vector4 *) &((Dali::Quaternion const *)arg1)->AsVector();
10015     } catch (std::out_of_range& e) {
10016       {
10017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10018       };
10019     } catch (std::exception& e) {
10020       {
10021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10022       };
10023     } catch (...) {
10024       {
10025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10026       };
10027     }
10028   }
10029   jresult = (void *)result;
10030   return jresult;
10031 }
10032
10033
10034 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_SetEuler(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
10035   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10036   Dali::Radian arg2 ;
10037   Dali::Radian arg3 ;
10038   Dali::Radian arg4 ;
10039   Dali::Radian *argp2 ;
10040   Dali::Radian *argp3 ;
10041   Dali::Radian *argp4 ;
10042
10043   arg1 = (Dali::Quaternion *)jarg1;
10044   argp2 = (Dali::Radian *)jarg2;
10045   if (!argp2) {
10046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10047     return ;
10048   }
10049   arg2 = *argp2;
10050   argp3 = (Dali::Radian *)jarg3;
10051   if (!argp3) {
10052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10053     return ;
10054   }
10055   arg3 = *argp3;
10056   argp4 = (Dali::Radian *)jarg4;
10057   if (!argp4) {
10058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10059     return ;
10060   }
10061   arg4 = *argp4;
10062   {
10063     try {
10064       (arg1)->SetEuler(arg2,arg3,arg4);
10065     } catch (std::out_of_range& e) {
10066       {
10067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10068       };
10069     } catch (std::exception& e) {
10070       {
10071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10072       };
10073     } catch (...) {
10074       {
10075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10076       };
10077     }
10078   }
10079 }
10080
10081
10082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_EulerAngles(void * jarg1) {
10083   void * jresult ;
10084   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10085   Dali::Vector4 result;
10086
10087   arg1 = (Dali::Quaternion *)jarg1;
10088   {
10089     try {
10090       result = ((Dali::Quaternion const *)arg1)->EulerAngles();
10091     } catch (std::out_of_range& e) {
10092       {
10093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10094       };
10095     } catch (std::exception& e) {
10096       {
10097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10098       };
10099     } catch (...) {
10100       {
10101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10102       };
10103     }
10104   }
10105   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
10106   return jresult;
10107 }
10108
10109
10110 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Add(void * jarg1, void * jarg2) {
10111   void * jresult ;
10112   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10113   Dali::Quaternion *arg2 = 0 ;
10114   Dali::Quaternion result;
10115
10116   arg1 = (Dali::Quaternion *)jarg1;
10117   arg2 = (Dali::Quaternion *)jarg2;
10118   if (!arg2) {
10119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10120     return 0;
10121   }
10122   {
10123     try {
10124       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10125     } catch (std::out_of_range& e) {
10126       {
10127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10128       };
10129     } catch (std::exception& e) {
10130       {
10131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10132       };
10133     } catch (...) {
10134       {
10135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10136       };
10137     }
10138   }
10139   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10140   return jresult;
10141 }
10142
10143
10144 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10145   void * jresult ;
10146   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10147   Dali::Quaternion *arg2 = 0 ;
10148   Dali::Quaternion result;
10149
10150   arg1 = (Dali::Quaternion *)jarg1;
10151   arg2 = (Dali::Quaternion *)jarg2;
10152   if (!arg2) {
10153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10154     return 0;
10155   }
10156   {
10157     try {
10158       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10159     } catch (std::out_of_range& e) {
10160       {
10161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10162       };
10163     } catch (std::exception& e) {
10164       {
10165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10166       };
10167     } catch (...) {
10168       {
10169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10170       };
10171     }
10172   }
10173   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10174   return jresult;
10175 }
10176
10177
10178 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10179   void * jresult ;
10180   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10181   Dali::Quaternion *arg2 = 0 ;
10182   Dali::Quaternion result;
10183
10184   arg1 = (Dali::Quaternion *)jarg1;
10185   arg2 = (Dali::Quaternion *)jarg2;
10186   if (!arg2) {
10187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10188     return 0;
10189   }
10190   {
10191     try {
10192       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10193     } catch (std::out_of_range& e) {
10194       {
10195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10196       };
10197     } catch (std::exception& e) {
10198       {
10199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10200       };
10201     } catch (...) {
10202       {
10203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10204       };
10205     }
10206   }
10207   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10208   return jresult;
10209 }
10210
10211
10212 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10213   void * jresult ;
10214   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10215   Dali::Vector3 *arg2 = 0 ;
10216   Dali::Vector3 result;
10217
10218   arg1 = (Dali::Quaternion *)jarg1;
10219   arg2 = (Dali::Vector3 *)jarg2;
10220   if (!arg2) {
10221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10222     return 0;
10223   }
10224   {
10225     try {
10226       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10227     } catch (std::out_of_range& e) {
10228       {
10229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10230       };
10231     } catch (std::exception& e) {
10232       {
10233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (...) {
10236       {
10237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10238       };
10239     }
10240   }
10241   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10242   return jresult;
10243 }
10244
10245
10246 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Divide__SWIG_0(void * jarg1, void * jarg2) {
10247   void * jresult ;
10248   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10249   Dali::Quaternion *arg2 = 0 ;
10250   Dali::Quaternion result;
10251
10252   arg1 = (Dali::Quaternion *)jarg1;
10253   arg2 = (Dali::Quaternion *)jarg2;
10254   if (!arg2) {
10255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10256     return 0;
10257   }
10258   {
10259     try {
10260       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10261     } catch (std::out_of_range& e) {
10262       {
10263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10264       };
10265     } catch (std::exception& e) {
10266       {
10267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10268       };
10269     } catch (...) {
10270       {
10271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10272       };
10273     }
10274   }
10275   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10276   return jresult;
10277 }
10278
10279
10280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_2(void * jarg1, float jarg2) {
10281   void * jresult ;
10282   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10283   float arg2 ;
10284   Dali::Quaternion result;
10285
10286   arg1 = (Dali::Quaternion *)jarg1;
10287   arg2 = (float)jarg2;
10288   {
10289     try {
10290       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10291     } catch (std::out_of_range& e) {
10292       {
10293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10294       };
10295     } catch (std::exception& e) {
10296       {
10297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10298       };
10299     } catch (...) {
10300       {
10301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10302       };
10303     }
10304   }
10305   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10306   return jresult;
10307 }
10308
10309
10310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Divide__SWIG_1(void * jarg1, float jarg2) {
10311   void * jresult ;
10312   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10313   float arg2 ;
10314   Dali::Quaternion result;
10315
10316   arg1 = (Dali::Quaternion *)jarg1;
10317   arg2 = (float)jarg2;
10318   {
10319     try {
10320       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10321     } catch (std::out_of_range& e) {
10322       {
10323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10324       };
10325     } catch (std::exception& e) {
10326       {
10327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (...) {
10330       {
10331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10332       };
10333     }
10334   }
10335   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10336   return jresult;
10337 }
10338
10339
10340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Subtract__SWIG_1(void * jarg1) {
10341   void * jresult ;
10342   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10343   Dali::Quaternion result;
10344
10345   arg1 = (Dali::Quaternion *)jarg1;
10346   {
10347     try {
10348       result = ((Dali::Quaternion const *)arg1)->operator -();
10349     } catch (std::out_of_range& e) {
10350       {
10351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10352       };
10353     } catch (std::exception& e) {
10354       {
10355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10356       };
10357     } catch (...) {
10358       {
10359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10360       };
10361     }
10362   }
10363   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10364   return jresult;
10365 }
10366
10367
10368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_AddAssign(void * jarg1, void * jarg2) {
10369   void * jresult ;
10370   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10371   Dali::Quaternion *arg2 = 0 ;
10372   Dali::Quaternion *result = 0 ;
10373
10374   arg1 = (Dali::Quaternion *)jarg1;
10375   arg2 = (Dali::Quaternion *)jarg2;
10376   if (!arg2) {
10377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10378     return 0;
10379   }
10380   {
10381     try {
10382       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10383     } catch (std::out_of_range& e) {
10384       {
10385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10386       };
10387     } catch (std::exception& e) {
10388       {
10389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10390       };
10391     } catch (...) {
10392       {
10393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10394       };
10395     }
10396   }
10397   jresult = (void *)result;
10398   return jresult;
10399 }
10400
10401
10402 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_SubtractAssign(void * jarg1, void * jarg2) {
10403   void * jresult ;
10404   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10405   Dali::Quaternion *arg2 = 0 ;
10406   Dali::Quaternion *result = 0 ;
10407
10408   arg1 = (Dali::Quaternion *)jarg1;
10409   arg2 = (Dali::Quaternion *)jarg2;
10410   if (!arg2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10412     return 0;
10413   }
10414   {
10415     try {
10416       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (...) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10428       };
10429     }
10430   }
10431   jresult = (void *)result;
10432   return jresult;
10433 }
10434
10435
10436 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10437   void * jresult ;
10438   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10439   Dali::Quaternion *arg2 = 0 ;
10440   Dali::Quaternion *result = 0 ;
10441
10442   arg1 = (Dali::Quaternion *)jarg1;
10443   arg2 = (Dali::Quaternion *)jarg2;
10444   if (!arg2) {
10445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10446     return 0;
10447   }
10448   {
10449     try {
10450       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (...) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10462       };
10463     }
10464   }
10465   jresult = (void *)result;
10466   return jresult;
10467 }
10468
10469
10470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10471   void * jresult ;
10472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10473   float arg2 ;
10474   Dali::Quaternion *result = 0 ;
10475
10476   arg1 = (Dali::Quaternion *)jarg1;
10477   arg2 = (float)jarg2;
10478   {
10479     try {
10480       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10481     } catch (std::out_of_range& e) {
10482       {
10483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10484       };
10485     } catch (std::exception& e) {
10486       {
10487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10488       };
10489     } catch (...) {
10490       {
10491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10492       };
10493     }
10494   }
10495   jresult = (void *)result;
10496   return jresult;
10497 }
10498
10499
10500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_DivideAssign(void * jarg1, float jarg2) {
10501   void * jresult ;
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503   float arg2 ;
10504   Dali::Quaternion *result = 0 ;
10505
10506   arg1 = (Dali::Quaternion *)jarg1;
10507   arg2 = (float)jarg2;
10508   {
10509     try {
10510       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (...) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10522       };
10523     }
10524   }
10525   jresult = (void *)result;
10526   return jresult;
10527 }
10528
10529
10530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_EqualTo(void * jarg1, void * jarg2) {
10531   unsigned int jresult ;
10532   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10533   Dali::Quaternion *arg2 = 0 ;
10534   bool result;
10535
10536   arg1 = (Dali::Quaternion *)jarg1;
10537   arg2 = (Dali::Quaternion *)jarg2;
10538   if (!arg2) {
10539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10540     return 0;
10541   }
10542   {
10543     try {
10544       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10545     } catch (std::out_of_range& e) {
10546       {
10547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10548       };
10549     } catch (std::exception& e) {
10550       {
10551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10552       };
10553     } catch (...) {
10554       {
10555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10556       };
10557     }
10558   }
10559   jresult = result;
10560   return jresult;
10561 }
10562
10563
10564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_NotEqualTo(void * jarg1, void * jarg2) {
10565   unsigned int jresult ;
10566   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10567   Dali::Quaternion *arg2 = 0 ;
10568   bool result;
10569
10570   arg1 = (Dali::Quaternion *)jarg1;
10571   arg2 = (Dali::Quaternion *)jarg2;
10572   if (!arg2) {
10573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10574     return 0;
10575   }
10576   {
10577     try {
10578       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10579     } catch (std::out_of_range& e) {
10580       {
10581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10582       };
10583     } catch (std::exception& e) {
10584       {
10585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10586       };
10587     } catch (...) {
10588       {
10589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10590       };
10591     }
10592   }
10593   jresult = result;
10594   return jresult;
10595 }
10596
10597
10598 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_Length(void * jarg1) {
10599   float jresult ;
10600   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10601   float result;
10602
10603   arg1 = (Dali::Quaternion *)jarg1;
10604   {
10605     try {
10606       result = (float)((Dali::Quaternion const *)arg1)->Length();
10607     } catch (std::out_of_range& e) {
10608       {
10609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (std::exception& e) {
10612       {
10613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (...) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10618       };
10619     }
10620   }
10621   jresult = result;
10622   return jresult;
10623 }
10624
10625
10626 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_LengthSquared(void * jarg1) {
10627   float jresult ;
10628   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10629   float result;
10630
10631   arg1 = (Dali::Quaternion *)jarg1;
10632   {
10633     try {
10634       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10635     } catch (std::out_of_range& e) {
10636       {
10637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10638       };
10639     } catch (std::exception& e) {
10640       {
10641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10642       };
10643     } catch (...) {
10644       {
10645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10646       };
10647     }
10648   }
10649   jresult = result;
10650   return jresult;
10651 }
10652
10653
10654 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Normalize(void * jarg1) {
10655   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10656
10657   arg1 = (Dali::Quaternion *)jarg1;
10658   {
10659     try {
10660       (arg1)->Normalize();
10661     } catch (std::out_of_range& e) {
10662       {
10663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10664       };
10665     } catch (std::exception& e) {
10666       {
10667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10668       };
10669     } catch (...) {
10670       {
10671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10672       };
10673     }
10674   }
10675 }
10676
10677
10678 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Normalized(void * jarg1) {
10679   void * jresult ;
10680   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10681   Dali::Quaternion result;
10682
10683   arg1 = (Dali::Quaternion *)jarg1;
10684   {
10685     try {
10686       result = ((Dali::Quaternion const *)arg1)->Normalized();
10687     } catch (std::out_of_range& e) {
10688       {
10689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10690       };
10691     } catch (std::exception& e) {
10692       {
10693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10694       };
10695     } catch (...) {
10696       {
10697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10698       };
10699     }
10700   }
10701   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10702   return jresult;
10703 }
10704
10705
10706 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Conjugate(void * jarg1) {
10707   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10708
10709   arg1 = (Dali::Quaternion *)jarg1;
10710   {
10711     try {
10712       (arg1)->Conjugate();
10713     } catch (std::out_of_range& e) {
10714       {
10715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10716       };
10717     } catch (std::exception& e) {
10718       {
10719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10720       };
10721     } catch (...) {
10722       {
10723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10724       };
10725     }
10726   }
10727 }
10728
10729
10730 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Invert(void * jarg1) {
10731   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10732
10733   arg1 = (Dali::Quaternion *)jarg1;
10734   {
10735     try {
10736       (arg1)->Invert();
10737     } catch (std::out_of_range& e) {
10738       {
10739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10740       };
10741     } catch (std::exception& e) {
10742       {
10743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10744       };
10745     } catch (...) {
10746       {
10747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10748       };
10749     }
10750   }
10751 }
10752
10753
10754 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Log(void * jarg1) {
10755   void * jresult ;
10756   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10757   Dali::Quaternion result;
10758
10759   arg1 = (Dali::Quaternion *)jarg1;
10760   {
10761     try {
10762       result = ((Dali::Quaternion const *)arg1)->Log();
10763     } catch (std::out_of_range& e) {
10764       {
10765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10766       };
10767     } catch (std::exception& e) {
10768       {
10769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10770       };
10771     } catch (...) {
10772       {
10773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10774       };
10775     }
10776   }
10777   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10778   return jresult;
10779 }
10780
10781
10782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Exp(void * jarg1) {
10783   void * jresult ;
10784   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10785   Dali::Quaternion result;
10786
10787   arg1 = (Dali::Quaternion *)jarg1;
10788   {
10789     try {
10790       result = ((Dali::Quaternion const *)arg1)->Exp();
10791     } catch (std::out_of_range& e) {
10792       {
10793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10794       };
10795     } catch (std::exception& e) {
10796       {
10797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10798       };
10799     } catch (...) {
10800       {
10801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10802       };
10803     }
10804   }
10805   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10806   return jresult;
10807 }
10808
10809
10810 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_Dot(void * jarg1, void * jarg2) {
10811   float jresult ;
10812   Dali::Quaternion *arg1 = 0 ;
10813   Dali::Quaternion *arg2 = 0 ;
10814   float result;
10815
10816   arg1 = (Dali::Quaternion *)jarg1;
10817   if (!arg1) {
10818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10819     return 0;
10820   }
10821   arg2 = (Dali::Quaternion *)jarg2;
10822   if (!arg2) {
10823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10824     return 0;
10825   }
10826   {
10827     try {
10828       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843   jresult = result;
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Lerp(void * jarg1, void * jarg2, float jarg3) {
10849   void * jresult ;
10850   Dali::Quaternion *arg1 = 0 ;
10851   Dali::Quaternion *arg2 = 0 ;
10852   float arg3 ;
10853   Dali::Quaternion result;
10854
10855   arg1 = (Dali::Quaternion *)jarg1;
10856   if (!arg1) {
10857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10858     return 0;
10859   }
10860   arg2 = (Dali::Quaternion *)jarg2;
10861   if (!arg2) {
10862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10863     return 0;
10864   }
10865   arg3 = (float)jarg3;
10866   {
10867     try {
10868       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10869     } catch (std::out_of_range& e) {
10870       {
10871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (std::exception& e) {
10874       {
10875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10876       };
10877     } catch (...) {
10878       {
10879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10880       };
10881     }
10882   }
10883   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Slerp(void * jarg1, void * jarg2, float jarg3) {
10889   void * jresult ;
10890   Dali::Quaternion *arg1 = 0 ;
10891   Dali::Quaternion *arg2 = 0 ;
10892   float arg3 ;
10893   Dali::Quaternion result;
10894
10895   arg1 = (Dali::Quaternion *)jarg1;
10896   if (!arg1) {
10897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10898     return 0;
10899   }
10900   arg2 = (Dali::Quaternion *)jarg2;
10901   if (!arg2) {
10902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10903     return 0;
10904   }
10905   arg3 = (float)jarg3;
10906   {
10907     try {
10908       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10909     } catch (std::out_of_range& e) {
10910       {
10911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10912       };
10913     } catch (std::exception& e) {
10914       {
10915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10916       };
10917     } catch (...) {
10918       {
10919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10920       };
10921     }
10922   }
10923   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10924   return jresult;
10925 }
10926
10927
10928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10929   void * jresult ;
10930   Dali::Quaternion *arg1 = 0 ;
10931   Dali::Quaternion *arg2 = 0 ;
10932   float arg3 ;
10933   Dali::Quaternion result;
10934
10935   arg1 = (Dali::Quaternion *)jarg1;
10936   if (!arg1) {
10937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10938     return 0;
10939   }
10940   arg2 = (Dali::Quaternion *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10943     return 0;
10944   }
10945   arg3 = (float)jarg3;
10946   {
10947     try {
10948       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10949     } catch (std::out_of_range& e) {
10950       {
10951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (std::exception& e) {
10954       {
10955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10956       };
10957     } catch (...) {
10958       {
10959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10960       };
10961     }
10962   }
10963   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10964   return jresult;
10965 }
10966
10967
10968 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10969   void * jresult ;
10970   Dali::Quaternion *arg1 = 0 ;
10971   Dali::Quaternion *arg2 = 0 ;
10972   Dali::Quaternion *arg3 = 0 ;
10973   Dali::Quaternion *arg4 = 0 ;
10974   float arg5 ;
10975   Dali::Quaternion result;
10976
10977   arg1 = (Dali::Quaternion *)jarg1;
10978   if (!arg1) {
10979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10980     return 0;
10981   }
10982   arg2 = (Dali::Quaternion *)jarg2;
10983   if (!arg2) {
10984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10985     return 0;
10986   }
10987   arg3 = (Dali::Quaternion *)jarg3;
10988   if (!arg3) {
10989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10990     return 0;
10991   }
10992   arg4 = (Dali::Quaternion *)jarg4;
10993   if (!arg4) {
10994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10995     return 0;
10996   }
10997   arg5 = (float)jarg5;
10998   {
10999     try {
11000       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11001     } catch (std::out_of_range& e) {
11002       {
11003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11004       };
11005     } catch (std::exception& e) {
11006       {
11007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11008       };
11009     } catch (...) {
11010       {
11011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11012       };
11013     }
11014   }
11015   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11016   return jresult;
11017 }
11018
11019
11020 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_AngleBetween(void * jarg1, void * jarg2) {
11021   float jresult ;
11022   Dali::Quaternion *arg1 = 0 ;
11023   Dali::Quaternion *arg2 = 0 ;
11024   float result;
11025
11026   arg1 = (Dali::Quaternion *)jarg1;
11027   if (!arg1) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11029     return 0;
11030   }
11031   arg2 = (Dali::Quaternion *)jarg2;
11032   if (!arg2) {
11033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11034     return 0;
11035   }
11036   {
11037     try {
11038       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11039     } catch (std::out_of_range& e) {
11040       {
11041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11042       };
11043     } catch (std::exception& e) {
11044       {
11045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11046       };
11047     } catch (...) {
11048       {
11049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11050       };
11051     }
11052   }
11053   jresult = result;
11054   return jresult;
11055 }
11056
11057
11058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Rotate__SWIG_0(void * jarg1, void * jarg2) {
11059   void * jresult ;
11060   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11061   Dali::Vector4 *arg2 = 0 ;
11062   Dali::Vector4 result;
11063
11064   arg1 = (Dali::Quaternion *)jarg1;
11065   arg2 = (Dali::Vector4 *)jarg2;
11066   if (!arg2) {
11067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11068     return 0;
11069   }
11070   {
11071     try {
11072       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector4 const &)*arg2);
11073     } catch (std::out_of_range& e) {
11074       {
11075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11076       };
11077     } catch (std::exception& e) {
11078       {
11079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11080       };
11081     } catch (...) {
11082       {
11083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11084       };
11085     }
11086   }
11087   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11088   return jresult;
11089 }
11090
11091
11092 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Rotate__SWIG_1(void * jarg1, void * jarg2) {
11093   void * jresult ;
11094   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11095   Dali::Vector3 *arg2 = 0 ;
11096   Dali::Vector3 result;
11097
11098   arg1 = (Dali::Quaternion *)jarg1;
11099   arg2 = (Dali::Vector3 *)jarg2;
11100   if (!arg2) {
11101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11102     return 0;
11103   }
11104   {
11105     try {
11106       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector3 const &)*arg2);
11107     } catch (std::out_of_range& e) {
11108       {
11109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11110       };
11111     } catch (std::exception& e) {
11112       {
11113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11114       };
11115     } catch (...) {
11116       {
11117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11118       };
11119     }
11120   }
11121   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_mVector_set(void * jarg1, void * jarg2) {
11127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11128   Dali::Vector4 *arg2 = (Dali::Vector4 *) 0 ;
11129
11130   arg1 = (Dali::Quaternion *)jarg1;
11131   arg2 = (Dali::Vector4 *)jarg2;
11132   if (arg1) (arg1)->mVector = *arg2;
11133 }
11134
11135
11136 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_mVector_get(void * jarg1) {
11137   void * jresult ;
11138   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11139   Dali::Vector4 *result = 0 ;
11140
11141   arg1 = (Dali::Quaternion *)jarg1;
11142   result = (Dali::Vector4 *)& ((arg1)->mVector);
11143   jresult = (void *)result;
11144   return jresult;
11145 }
11146
11147
11148 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_0() {
11149   void * jresult ;
11150   Dali::Matrix *result = 0 ;
11151
11152   {
11153     try {
11154       result = (Dali::Matrix *)new Dali::Matrix();
11155     } catch (std::out_of_range& e) {
11156       {
11157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11158       };
11159     } catch (std::exception& e) {
11160       {
11161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11162       };
11163     } catch (...) {
11164       {
11165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11166       };
11167     }
11168   }
11169   jresult = (void *)result;
11170   return jresult;
11171 }
11172
11173
11174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_1(unsigned int jarg1) {
11175   void * jresult ;
11176   bool arg1 ;
11177   Dali::Matrix *result = 0 ;
11178
11179   arg1 = jarg1 ? true : false;
11180   {
11181     try {
11182       result = (Dali::Matrix *)new Dali::Matrix(arg1);
11183     } catch (std::out_of_range& e) {
11184       {
11185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (std::exception& e) {
11188       {
11189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197   jresult = (void *)result;
11198   return jresult;
11199 }
11200
11201
11202 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_2(float* jarg1) {
11203   void * jresult ;
11204   float *arg1 = (float *) 0 ;
11205   Dali::Matrix *result = 0 ;
11206
11207   arg1 = jarg1;
11208   {
11209     try {
11210       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
11211     } catch (std::out_of_range& e) {
11212       {
11213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11214       };
11215     } catch (std::exception& e) {
11216       {
11217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (...) {
11220       {
11221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11222       };
11223     }
11224   }
11225   jresult = (void *)result;
11226
11227
11228   return jresult;
11229 }
11230
11231
11232 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_3(void * jarg1) {
11233   void * jresult ;
11234   Dali::Quaternion *arg1 = 0 ;
11235   Dali::Matrix *result = 0 ;
11236
11237   arg1 = (Dali::Quaternion *)jarg1;
11238   if (!arg1) {
11239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11240     return 0;
11241   }
11242   {
11243     try {
11244       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11245     } catch (std::out_of_range& e) {
11246       {
11247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11248       };
11249     } catch (std::exception& e) {
11250       {
11251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11252       };
11253     } catch (...) {
11254       {
11255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11256       };
11257     }
11258   }
11259   jresult = (void *)result;
11260   return jresult;
11261 }
11262
11263
11264 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_4(void * jarg1) {
11265   void * jresult ;
11266   Dali::Matrix *arg1 = 0 ;
11267   Dali::Matrix *result = 0 ;
11268
11269   arg1 = (Dali::Matrix *)jarg1;
11270   if (!arg1) {
11271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11272     return 0;
11273   }
11274   {
11275     try {
11276       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11277     } catch (std::out_of_range& e) {
11278       {
11279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11280       };
11281     } catch (std::exception& e) {
11282       {
11283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11284       };
11285     } catch (...) {
11286       {
11287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11288       };
11289     }
11290   }
11291   jresult = (void *)result;
11292   return jresult;
11293 }
11294
11295
11296 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_Assign(void * jarg1, void * jarg2) {
11297   void * jresult ;
11298   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11299   Dali::Matrix *arg2 = 0 ;
11300   Dali::Matrix *result = 0 ;
11301
11302   arg1 = (Dali::Matrix *)jarg1;
11303   arg2 = (Dali::Matrix *)jarg2;
11304   if (!arg2) {
11305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11306     return 0;
11307   }
11308   {
11309     try {
11310       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11311     } catch (std::out_of_range& e) {
11312       {
11313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11314       };
11315     } catch (std::exception& e) {
11316       {
11317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11318       };
11319     } catch (...) {
11320       {
11321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11322       };
11323     }
11324   }
11325   jresult = (void *)result;
11326   return jresult;
11327 }
11328
11329
11330 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_IDENTITY_get() {
11331   void * jresult ;
11332   Dali::Matrix *result = 0 ;
11333
11334   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11335   jresult = (void *)result;
11336   return jresult;
11337 }
11338
11339
11340 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetIdentity(void * jarg1) {
11341   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11342
11343   arg1 = (Dali::Matrix *)jarg1;
11344   {
11345     try {
11346       (arg1)->SetIdentity();
11347     } catch (std::out_of_range& e) {
11348       {
11349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11350       };
11351     } catch (std::exception& e) {
11352       {
11353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11354       };
11355     } catch (...) {
11356       {
11357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11358       };
11359     }
11360   }
11361 }
11362
11363
11364 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11365   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11366   Dali::Vector3 *arg2 = 0 ;
11367
11368   arg1 = (Dali::Matrix *)jarg1;
11369   arg2 = (Dali::Vector3 *)jarg2;
11370   if (!arg2) {
11371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11372     return ;
11373   }
11374   {
11375     try {
11376       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11377     } catch (std::out_of_range& e) {
11378       {
11379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11380       };
11381     } catch (std::exception& e) {
11382       {
11383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11384       };
11385     } catch (...) {
11386       {
11387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11388       };
11389     }
11390   }
11391 }
11392
11393
11394 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11395   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11396   Dali::Matrix *arg2 = 0 ;
11397
11398   arg1 = (Dali::Matrix *)jarg1;
11399   arg2 = (Dali::Matrix *)jarg2;
11400   if (!arg2) {
11401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11402     return ;
11403   }
11404   {
11405     try {
11406       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11407     } catch (std::out_of_range& e) {
11408       {
11409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11410       };
11411     } catch (std::exception& e) {
11412       {
11413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11414       };
11415     } catch (...) {
11416       {
11417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11418       };
11419     }
11420   }
11421 }
11422
11423
11424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_Invert(void * jarg1) {
11425   unsigned int jresult ;
11426   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11427   bool result;
11428
11429   arg1 = (Dali::Matrix *)jarg1;
11430   {
11431     try {
11432       result = (bool)(arg1)->Invert();
11433     } catch (std::out_of_range& e) {
11434       {
11435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (std::exception& e) {
11438       {
11439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (...) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11444       };
11445     }
11446   }
11447   jresult = result;
11448   return jresult;
11449 }
11450
11451
11452 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Transpose(void * jarg1) {
11453   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11454
11455   arg1 = (Dali::Matrix *)jarg1;
11456   {
11457     try {
11458       (arg1)->Transpose();
11459     } catch (std::out_of_range& e) {
11460       {
11461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11462       };
11463     } catch (std::exception& e) {
11464       {
11465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11466       };
11467     } catch (...) {
11468       {
11469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11470       };
11471     }
11472   }
11473 }
11474
11475
11476 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetXAxis(void * jarg1) {
11477   void * jresult ;
11478   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11479   Dali::Vector3 result;
11480
11481   arg1 = (Dali::Matrix *)jarg1;
11482   {
11483     try {
11484       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11485     } catch (std::out_of_range& e) {
11486       {
11487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11488       };
11489     } catch (std::exception& e) {
11490       {
11491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11492       };
11493     } catch (...) {
11494       {
11495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11496       };
11497     }
11498   }
11499   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetYAxis(void * jarg1) {
11505   void * jresult ;
11506   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11507   Dali::Vector3 result;
11508
11509   arg1 = (Dali::Matrix *)jarg1;
11510   {
11511     try {
11512       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11513     } catch (std::out_of_range& e) {
11514       {
11515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (std::exception& e) {
11518       {
11519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (...) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11524       };
11525     }
11526   }
11527   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11528   return jresult;
11529 }
11530
11531
11532 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetZAxis(void * jarg1) {
11533   void * jresult ;
11534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11535   Dali::Vector3 result;
11536
11537   arg1 = (Dali::Matrix *)jarg1;
11538   {
11539     try {
11540       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11541     } catch (std::out_of_range& e) {
11542       {
11543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11544       };
11545     } catch (std::exception& e) {
11546       {
11547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11548       };
11549     } catch (...) {
11550       {
11551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11552       };
11553     }
11554   }
11555   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11556   return jresult;
11557 }
11558
11559
11560 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11561   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11562   Dali::Vector3 *arg2 = 0 ;
11563
11564   arg1 = (Dali::Matrix *)jarg1;
11565   arg2 = (Dali::Vector3 *)jarg2;
11566   if (!arg2) {
11567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11568     return ;
11569   }
11570   {
11571     try {
11572       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11573     } catch (std::out_of_range& e) {
11574       {
11575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11576       };
11577     } catch (std::exception& e) {
11578       {
11579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11580       };
11581     } catch (...) {
11582       {
11583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11584       };
11585     }
11586   }
11587 }
11588
11589
11590 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11591   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11592   Dali::Vector3 *arg2 = 0 ;
11593
11594   arg1 = (Dali::Matrix *)jarg1;
11595   arg2 = (Dali::Vector3 *)jarg2;
11596   if (!arg2) {
11597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11598     return ;
11599   }
11600   {
11601     try {
11602       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11603     } catch (std::out_of_range& e) {
11604       {
11605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11606       };
11607     } catch (std::exception& e) {
11608       {
11609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11610       };
11611     } catch (...) {
11612       {
11613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11614       };
11615     }
11616   }
11617 }
11618
11619
11620 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11621   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11622   Dali::Vector3 *arg2 = 0 ;
11623
11624   arg1 = (Dali::Matrix *)jarg1;
11625   arg2 = (Dali::Vector3 *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11628     return ;
11629   }
11630   {
11631     try {
11632       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11633     } catch (std::out_of_range& e) {
11634       {
11635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11636       };
11637     } catch (std::exception& e) {
11638       {
11639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11640       };
11641     } catch (...) {
11642       {
11643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11644       };
11645     }
11646   }
11647 }
11648
11649
11650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetTranslation(void * jarg1) {
11651   void * jresult ;
11652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11653   Dali::Vector4 *result = 0 ;
11654
11655   arg1 = (Dali::Matrix *)jarg1;
11656   {
11657     try {
11658       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11659     } catch (std::out_of_range& e) {
11660       {
11661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (std::exception& e) {
11664       {
11665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11666       };
11667     } catch (...) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11670       };
11671     }
11672   }
11673   jresult = (void *)result;
11674   return jresult;
11675 }
11676
11677
11678 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetTranslation3(void * jarg1) {
11679   void * jresult ;
11680   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11681   Dali::Vector3 *result = 0 ;
11682
11683   arg1 = (Dali::Matrix *)jarg1;
11684   {
11685     try {
11686       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11687     } catch (std::out_of_range& e) {
11688       {
11689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11690       };
11691     } catch (std::exception& e) {
11692       {
11693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11694       };
11695     } catch (...) {
11696       {
11697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11698       };
11699     }
11700   }
11701   jresult = (void *)result;
11702   return jresult;
11703 }
11704
11705
11706 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11707   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11708   Dali::Vector4 *arg2 = 0 ;
11709
11710   arg1 = (Dali::Matrix *)jarg1;
11711   arg2 = (Dali::Vector4 *)jarg2;
11712   if (!arg2) {
11713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11714     return ;
11715   }
11716   {
11717     try {
11718       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11719     } catch (std::out_of_range& e) {
11720       {
11721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11722       };
11723     } catch (std::exception& e) {
11724       {
11725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (...) {
11728       {
11729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11730       };
11731     }
11732   }
11733 }
11734
11735
11736 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11737   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11738   Dali::Vector3 *arg2 = 0 ;
11739
11740   arg1 = (Dali::Matrix *)jarg1;
11741   arg2 = (Dali::Vector3 *)jarg2;
11742   if (!arg2) {
11743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11744     return ;
11745   }
11746   {
11747     try {
11748       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11749     } catch (std::out_of_range& e) {
11750       {
11751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11752       };
11753     } catch (std::exception& e) {
11754       {
11755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11756       };
11757     } catch (...) {
11758       {
11759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11760       };
11761     }
11762   }
11763 }
11764
11765
11766 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_OrthoNormalize(void * jarg1) {
11767   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11768
11769   arg1 = (Dali::Matrix *)jarg1;
11770   {
11771     try {
11772       (arg1)->OrthoNormalize();
11773     } catch (std::out_of_range& e) {
11774       {
11775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11776       };
11777     } catch (std::exception& e) {
11778       {
11779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11780       };
11781     } catch (...) {
11782       {
11783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11784       };
11785     }
11786   }
11787 }
11788
11789
11790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_AsFloat__SWIG_0(void * jarg1) {
11791   void * jresult ;
11792   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11793   float *result = 0 ;
11794
11795   arg1 = (Dali::Matrix *)jarg1;
11796   {
11797     try {
11798       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11799     } catch (std::out_of_range& e) {
11800       {
11801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11802       };
11803     } catch (std::exception& e) {
11804       {
11805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11806       };
11807     } catch (...) {
11808       {
11809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11810       };
11811     }
11812   }
11813   jresult = (void *)result;
11814   return jresult;
11815 }
11816
11817
11818 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11819   Dali::Matrix *arg1 = 0 ;
11820   Dali::Matrix *arg2 = 0 ;
11821   Dali::Matrix *arg3 = 0 ;
11822
11823   arg1 = (Dali::Matrix *)jarg1;
11824   if (!arg1) {
11825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11826     return ;
11827   }
11828   arg2 = (Dali::Matrix *)jarg2;
11829   if (!arg2) {
11830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11831     return ;
11832   }
11833   arg3 = (Dali::Matrix *)jarg3;
11834   if (!arg3) {
11835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11836     return ;
11837   }
11838   {
11839     try {
11840       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11841     } catch (std::out_of_range& e) {
11842       {
11843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11844       };
11845     } catch (std::exception& e) {
11846       {
11847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11848       };
11849     } catch (...) {
11850       {
11851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11852       };
11853     }
11854   }
11855 }
11856
11857
11858 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11859   Dali::Matrix *arg1 = 0 ;
11860   Dali::Matrix *arg2 = 0 ;
11861   Dali::Quaternion *arg3 = 0 ;
11862
11863   arg1 = (Dali::Matrix *)jarg1;
11864   if (!arg1) {
11865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11866     return ;
11867   }
11868   arg2 = (Dali::Matrix *)jarg2;
11869   if (!arg2) {
11870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11871     return ;
11872   }
11873   arg3 = (Dali::Quaternion *)jarg3;
11874   if (!arg3) {
11875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11876     return ;
11877   }
11878   {
11879     try {
11880       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11881     } catch (std::out_of_range& e) {
11882       {
11883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11884       };
11885     } catch (std::exception& e) {
11886       {
11887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11888       };
11889     } catch (...) {
11890       {
11891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11892       };
11893     }
11894   }
11895 }
11896
11897
11898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11899   void * jresult ;
11900   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11901   Dali::Vector4 *arg2 = 0 ;
11902   Dali::Vector4 result;
11903
11904   arg1 = (Dali::Matrix *)jarg1;
11905   arg2 = (Dali::Vector4 *)jarg2;
11906   if (!arg2) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11908     return 0;
11909   }
11910   {
11911     try {
11912       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11913     } catch (std::out_of_range& e) {
11914       {
11915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11916       };
11917     } catch (std::exception& e) {
11918       {
11919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11920       };
11921     } catch (...) {
11922       {
11923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11924       };
11925     }
11926   }
11927   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11928   return jresult;
11929 }
11930
11931
11932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_EqualTo(void * jarg1, void * jarg2) {
11933   unsigned int jresult ;
11934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11935   Dali::Matrix *arg2 = 0 ;
11936   bool result;
11937
11938   arg1 = (Dali::Matrix *)jarg1;
11939   arg2 = (Dali::Matrix *)jarg2;
11940   if (!arg2) {
11941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11942     return 0;
11943   }
11944   {
11945     try {
11946       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11947     } catch (std::out_of_range& e) {
11948       {
11949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11950       };
11951     } catch (std::exception& e) {
11952       {
11953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11954       };
11955     } catch (...) {
11956       {
11957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11958       };
11959     }
11960   }
11961   jresult = result;
11962   return jresult;
11963 }
11964
11965
11966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11967   unsigned int jresult ;
11968   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11969   Dali::Matrix *arg2 = 0 ;
11970   bool result;
11971
11972   arg1 = (Dali::Matrix *)jarg1;
11973   arg2 = (Dali::Matrix *)jarg2;
11974   if (!arg2) {
11975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11976     return 0;
11977   }
11978   {
11979     try {
11980       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11981     } catch (std::out_of_range& e) {
11982       {
11983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11984       };
11985     } catch (std::exception& e) {
11986       {
11987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11988       };
11989     } catch (...) {
11990       {
11991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11992       };
11993     }
11994   }
11995   jresult = result;
11996   return jresult;
11997 }
11998
11999
12000 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12001   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12002   Dali::Vector3 *arg2 = 0 ;
12003   Dali::Quaternion *arg3 = 0 ;
12004   Dali::Vector3 *arg4 = 0 ;
12005
12006   arg1 = (Dali::Matrix *)jarg1;
12007   arg2 = (Dali::Vector3 *)jarg2;
12008   if (!arg2) {
12009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12010     return ;
12011   }
12012   arg3 = (Dali::Quaternion *)jarg3;
12013   if (!arg3) {
12014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12015     return ;
12016   }
12017   arg4 = (Dali::Vector3 *)jarg4;
12018   if (!arg4) {
12019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12020     return ;
12021   }
12022   {
12023     try {
12024       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12025     } catch (std::out_of_range& e) {
12026       {
12027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12028       };
12029     } catch (std::exception& e) {
12030       {
12031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12032       };
12033     } catch (...) {
12034       {
12035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12036       };
12037     }
12038   }
12039 }
12040
12041
12042 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12043   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12044   Dali::Vector3 *arg2 = 0 ;
12045   Dali::Quaternion *arg3 = 0 ;
12046   Dali::Vector3 *arg4 = 0 ;
12047
12048   arg1 = (Dali::Matrix *)jarg1;
12049   arg2 = (Dali::Vector3 *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12052     return ;
12053   }
12054   arg3 = (Dali::Quaternion *)jarg3;
12055   if (!arg3) {
12056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12057     return ;
12058   }
12059   arg4 = (Dali::Vector3 *)jarg4;
12060   if (!arg4) {
12061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12062     return ;
12063   }
12064   {
12065     try {
12066       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12067     } catch (std::out_of_range& e) {
12068       {
12069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12070       };
12071     } catch (std::exception& e) {
12072       {
12073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12074       };
12075     } catch (...) {
12076       {
12077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12078       };
12079     }
12080   }
12081 }
12082
12083
12084 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
12085   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12086   Dali::Vector3 *arg2 = 0 ;
12087   Dali::Vector3 *arg3 = 0 ;
12088   Dali::Vector3 *arg4 = 0 ;
12089   Dali::Vector3 *arg5 = 0 ;
12090
12091   arg1 = (Dali::Matrix *)jarg1;
12092   arg2 = (Dali::Vector3 *)jarg2;
12093   if (!arg2) {
12094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12095     return ;
12096   }
12097   arg3 = (Dali::Vector3 *)jarg3;
12098   if (!arg3) {
12099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12100     return ;
12101   }
12102   arg4 = (Dali::Vector3 *)jarg4;
12103   if (!arg4) {
12104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12105     return ;
12106   }
12107   arg5 = (Dali::Vector3 *)jarg5;
12108   if (!arg5) {
12109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12110     return ;
12111   }
12112   {
12113     try {
12114       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12126       };
12127     }
12128   }
12129 }
12130
12131
12132 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12133   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12134   Dali::Vector3 *arg2 = 0 ;
12135   Dali::Quaternion *arg3 = 0 ;
12136   Dali::Vector3 *arg4 = 0 ;
12137
12138   arg1 = (Dali::Matrix *)jarg1;
12139   arg2 = (Dali::Vector3 *)jarg2;
12140   if (!arg2) {
12141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12142     return ;
12143   }
12144   arg3 = (Dali::Quaternion *)jarg3;
12145   if (!arg3) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
12147     return ;
12148   }
12149   arg4 = (Dali::Vector3 *)jarg4;
12150   if (!arg4) {
12151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12152     return ;
12153   }
12154   {
12155     try {
12156       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
12157     } catch (std::out_of_range& e) {
12158       {
12159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12160       };
12161     } catch (std::exception& e) {
12162       {
12163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12164       };
12165     } catch (...) {
12166       {
12167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12168       };
12169     }
12170   }
12171 }
12172
12173
12174 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Matrix(void * jarg1) {
12175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12176
12177   arg1 = (Dali::Matrix *)jarg1;
12178   {
12179     try {
12180       delete arg1;
12181     } catch (std::out_of_range& e) {
12182       {
12183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12184       };
12185     } catch (std::exception& e) {
12186       {
12187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12188       };
12189     } catch (...) {
12190       {
12191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12192       };
12193     }
12194   }
12195 }
12196
12197
12198 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_IDENTITY_get() {
12199   void * jresult ;
12200   Dali::Matrix3 *result = 0 ;
12201
12202   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
12203   jresult = (void *)result;
12204   return jresult;
12205 }
12206
12207
12208 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_0() {
12209   void * jresult ;
12210   Dali::Matrix3 *result = 0 ;
12211
12212   {
12213     try {
12214       result = (Dali::Matrix3 *)new Dali::Matrix3();
12215     } catch (std::out_of_range& e) {
12216       {
12217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12218       };
12219     } catch (std::exception& e) {
12220       {
12221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (...) {
12224       {
12225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12226       };
12227     }
12228   }
12229   jresult = (void *)result;
12230   return jresult;
12231 }
12232
12233
12234 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_1(void * jarg1) {
12235   void * jresult ;
12236   Dali::Matrix3 *arg1 = 0 ;
12237   Dali::Matrix3 *result = 0 ;
12238
12239   arg1 = (Dali::Matrix3 *)jarg1;
12240   if (!arg1) {
12241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12242     return 0;
12243   }
12244   {
12245     try {
12246       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (...) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12258       };
12259     }
12260   }
12261   jresult = (void *)result;
12262   return jresult;
12263 }
12264
12265
12266 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_2(void * jarg1) {
12267   void * jresult ;
12268   Dali::Matrix *arg1 = 0 ;
12269   Dali::Matrix3 *result = 0 ;
12270
12271   arg1 = (Dali::Matrix *)jarg1;
12272   if (!arg1) {
12273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12274     return 0;
12275   }
12276   {
12277     try {
12278       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12279     } catch (std::out_of_range& e) {
12280       {
12281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12282       };
12283     } catch (std::exception& e) {
12284       {
12285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12286       };
12287     } catch (...) {
12288       {
12289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12290       };
12291     }
12292   }
12293   jresult = (void *)result;
12294   return jresult;
12295 }
12296
12297
12298 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
12299   void * jresult ;
12300   float arg1 ;
12301   float arg2 ;
12302   float arg3 ;
12303   float arg4 ;
12304   float arg5 ;
12305   float arg6 ;
12306   float arg7 ;
12307   float arg8 ;
12308   float arg9 ;
12309   Dali::Matrix3 *result = 0 ;
12310
12311   arg1 = (float)jarg1;
12312   arg2 = (float)jarg2;
12313   arg3 = (float)jarg3;
12314   arg4 = (float)jarg4;
12315   arg5 = (float)jarg5;
12316   arg6 = (float)jarg6;
12317   arg7 = (float)jarg7;
12318   arg8 = (float)jarg8;
12319   arg9 = (float)jarg9;
12320   {
12321     try {
12322       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12323     } catch (std::out_of_range& e) {
12324       {
12325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (std::exception& e) {
12328       {
12329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (...) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12334       };
12335     }
12336   }
12337   jresult = (void *)result;
12338   return jresult;
12339 }
12340
12341
12342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12343   void * jresult ;
12344   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12345   Dali::Matrix3 *arg2 = 0 ;
12346   Dali::Matrix3 *result = 0 ;
12347
12348   arg1 = (Dali::Matrix3 *)jarg1;
12349   arg2 = (Dali::Matrix3 *)jarg2;
12350   if (!arg2) {
12351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12352     return 0;
12353   }
12354   {
12355     try {
12356       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12357     } catch (std::out_of_range& e) {
12358       {
12359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12360       };
12361     } catch (std::exception& e) {
12362       {
12363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12364       };
12365     } catch (...) {
12366       {
12367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12368       };
12369     }
12370   }
12371   jresult = (void *)result;
12372   return jresult;
12373 }
12374
12375
12376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12377   void * jresult ;
12378   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12379   Dali::Matrix *arg2 = 0 ;
12380   Dali::Matrix3 *result = 0 ;
12381
12382   arg1 = (Dali::Matrix3 *)jarg1;
12383   arg2 = (Dali::Matrix *)jarg2;
12384   if (!arg2) {
12385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12386     return 0;
12387   }
12388   {
12389     try {
12390       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12391     } catch (std::out_of_range& e) {
12392       {
12393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12394       };
12395     } catch (std::exception& e) {
12396       {
12397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12398       };
12399     } catch (...) {
12400       {
12401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12402       };
12403     }
12404   }
12405   jresult = (void *)result;
12406   return jresult;
12407 }
12408
12409
12410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12411   unsigned int jresult ;
12412   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12413   Dali::Matrix3 *arg2 = 0 ;
12414   bool result;
12415
12416   arg1 = (Dali::Matrix3 *)jarg1;
12417   arg2 = (Dali::Matrix3 *)jarg2;
12418   if (!arg2) {
12419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12420     return 0;
12421   }
12422   {
12423     try {
12424       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12425     } catch (std::out_of_range& e) {
12426       {
12427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12428       };
12429     } catch (std::exception& e) {
12430       {
12431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12432       };
12433     } catch (...) {
12434       {
12435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12436       };
12437     }
12438   }
12439   jresult = result;
12440   return jresult;
12441 }
12442
12443
12444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12445   unsigned int jresult ;
12446   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12447   Dali::Matrix3 *arg2 = 0 ;
12448   bool result;
12449
12450   arg1 = (Dali::Matrix3 *)jarg1;
12451   arg2 = (Dali::Matrix3 *)jarg2;
12452   if (!arg2) {
12453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12454     return 0;
12455   }
12456   {
12457     try {
12458       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12459     } catch (std::out_of_range& e) {
12460       {
12461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12462       };
12463     } catch (std::exception& e) {
12464       {
12465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12466       };
12467     } catch (...) {
12468       {
12469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12470       };
12471     }
12472   }
12473   jresult = result;
12474   return jresult;
12475 }
12476
12477
12478 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Matrix3(void * jarg1) {
12479   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12480
12481   arg1 = (Dali::Matrix3 *)jarg1;
12482   {
12483     try {
12484       delete arg1;
12485     } catch (std::out_of_range& e) {
12486       {
12487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (std::exception& e) {
12490       {
12491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499 }
12500
12501
12502 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_SetIdentity(void * jarg1) {
12503   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12504
12505   arg1 = (Dali::Matrix3 *)jarg1;
12506   {
12507     try {
12508       (arg1)->SetIdentity();
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12516       };
12517     } catch (...) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12520       };
12521     }
12522   }
12523 }
12524
12525
12526 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12527   void * jresult ;
12528   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12529   float *result = 0 ;
12530
12531   arg1 = (Dali::Matrix3 *)jarg1;
12532   {
12533     try {
12534       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12535     } catch (std::out_of_range& e) {
12536       {
12537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12538       };
12539     } catch (std::exception& e) {
12540       {
12541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12542       };
12543     } catch (...) {
12544       {
12545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12546       };
12547     }
12548   }
12549   jresult = (void *)result;
12550   return jresult;
12551 }
12552
12553
12554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_Invert(void * jarg1) {
12555   unsigned int jresult ;
12556   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12557   bool result;
12558
12559   arg1 = (Dali::Matrix3 *)jarg1;
12560   {
12561     try {
12562       result = (bool)(arg1)->Invert();
12563     } catch (std::out_of_range& e) {
12564       {
12565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12566       };
12567     } catch (std::exception& e) {
12568       {
12569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12570       };
12571     } catch (...) {
12572       {
12573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12574       };
12575     }
12576   }
12577   jresult = result;
12578   return jresult;
12579 }
12580
12581
12582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_Transpose(void * jarg1) {
12583   unsigned int jresult ;
12584   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12585   bool result;
12586
12587   arg1 = (Dali::Matrix3 *)jarg1;
12588   {
12589     try {
12590       result = (bool)(arg1)->Transpose();
12591     } catch (std::out_of_range& e) {
12592       {
12593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12594       };
12595     } catch (std::exception& e) {
12596       {
12597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (...) {
12600       {
12601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12602       };
12603     }
12604   }
12605   jresult = result;
12606   return jresult;
12607 }
12608
12609
12610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_Scale(void * jarg1, float jarg2) {
12611   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12612   float arg2 ;
12613
12614   arg1 = (Dali::Matrix3 *)jarg1;
12615   arg2 = (float)jarg2;
12616   {
12617     try {
12618       (arg1)->Scale(arg2);
12619     } catch (std::out_of_range& e) {
12620       {
12621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12622       };
12623     } catch (std::exception& e) {
12624       {
12625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12626       };
12627     } catch (...) {
12628       {
12629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12630       };
12631     }
12632   }
12633 }
12634
12635
12636 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Matrix3_Magnitude(void * jarg1) {
12637   float jresult ;
12638   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12639   float result;
12640
12641   arg1 = (Dali::Matrix3 *)jarg1;
12642   {
12643     try {
12644       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12645     } catch (std::out_of_range& e) {
12646       {
12647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12648       };
12649     } catch (std::exception& e) {
12650       {
12651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12652       };
12653     } catch (...) {
12654       {
12655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12656       };
12657     }
12658   }
12659   jresult = result;
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_ScaledInverseTranspose(void * jarg1) {
12665   unsigned int jresult ;
12666   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12667   bool result;
12668
12669   arg1 = (Dali::Matrix3 *)jarg1;
12670   {
12671     try {
12672       result = (bool)(arg1)->ScaledInverseTranspose();
12673     } catch (std::out_of_range& e) {
12674       {
12675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12676       };
12677     } catch (std::exception& e) {
12678       {
12679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12680       };
12681     } catch (...) {
12682       {
12683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12684       };
12685     }
12686   }
12687   jresult = result;
12688   return jresult;
12689 }
12690
12691
12692 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12693   Dali::Matrix3 *arg1 = 0 ;
12694   Dali::Matrix3 *arg2 = 0 ;
12695   Dali::Matrix3 *arg3 = 0 ;
12696
12697   arg1 = (Dali::Matrix3 *)jarg1;
12698   if (!arg1) {
12699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12700     return ;
12701   }
12702   arg2 = (Dali::Matrix3 *)jarg2;
12703   if (!arg2) {
12704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12705     return ;
12706   }
12707   arg3 = (Dali::Matrix3 *)jarg3;
12708   if (!arg3) {
12709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12710     return ;
12711   }
12712   {
12713     try {
12714       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12715     } catch (std::out_of_range& e) {
12716       {
12717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12718       };
12719     } catch (std::exception& e) {
12720       {
12721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12722       };
12723     } catch (...) {
12724       {
12725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12726       };
12727     }
12728   }
12729 }
12730
12731
12732 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Range(float jarg1, float jarg2) {
12733   float jresult ;
12734   float arg1 ;
12735   float arg2 ;
12736   float result;
12737
12738   arg1 = (float)jarg1;
12739   arg2 = (float)jarg2;
12740   {
12741     try {
12742       result = (float)Dali::Random::Range(arg1,arg2);
12743     } catch (std::out_of_range& e) {
12744       {
12745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12746       };
12747     } catch (std::exception& e) {
12748       {
12749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12750       };
12751     } catch (...) {
12752       {
12753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12754       };
12755     }
12756   }
12757   jresult = result;
12758   return jresult;
12759 }
12760
12761
12762 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Axis() {
12763   void * jresult ;
12764   Dali::Vector4 result;
12765
12766   {
12767     try {
12768       result = Dali::Random::Axis();
12769     } catch (std::out_of_range& e) {
12770       {
12771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12772       };
12773     } catch (std::exception& e) {
12774       {
12775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12776       };
12777     } catch (...) {
12778       {
12779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12780       };
12781     }
12782   }
12783   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12784   return jresult;
12785 }
12786
12787
12788 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleAxis__SWIG_0() {
12789   void * jresult ;
12790   Dali::AngleAxis *result = 0 ;
12791
12792   {
12793     try {
12794       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12795     } catch (std::out_of_range& e) {
12796       {
12797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12798       };
12799     } catch (std::exception& e) {
12800       {
12801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12802       };
12803     } catch (...) {
12804       {
12805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12806       };
12807     }
12808   }
12809   jresult = (void *)result;
12810   return jresult;
12811 }
12812
12813
12814 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12815   void * jresult ;
12816   Dali::Radian arg1 ;
12817   Dali::Vector3 *arg2 = 0 ;
12818   Dali::Radian *argp1 ;
12819   Dali::AngleAxis *result = 0 ;
12820
12821   argp1 = (Dali::Radian *)jarg1;
12822   if (!argp1) {
12823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12824     return 0;
12825   }
12826   arg1 = *argp1;
12827   arg2 = (Dali::Vector3 *)jarg2;
12828   if (!arg2) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12830     return 0;
12831   }
12832   {
12833     try {
12834       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12842       };
12843     } catch (...) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12846       };
12847     }
12848   }
12849   jresult = (void *)result;
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12855   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12856   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12857
12858   arg1 = (Dali::AngleAxis *)jarg1;
12859   arg2 = (Dali::Radian *)jarg2;
12860   if (arg1) (arg1)->angle = *arg2;
12861 }
12862
12863
12864 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleAxis_angle_get(void * jarg1) {
12865   void * jresult ;
12866   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12867   Dali::Radian *result = 0 ;
12868
12869   arg1 = (Dali::AngleAxis *)jarg1;
12870   result = (Dali::Radian *)& ((arg1)->angle);
12871   jresult = (void *)result;
12872   return jresult;
12873 }
12874
12875
12876 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12877   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12878   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12879
12880   arg1 = (Dali::AngleAxis *)jarg1;
12881   arg2 = (Dali::Vector3 *)jarg2;
12882   if (arg1) (arg1)->axis = *arg2;
12883 }
12884
12885
12886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleAxis_axis_get(void * jarg1) {
12887   void * jresult ;
12888   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12889   Dali::Vector3 *result = 0 ;
12890
12891   arg1 = (Dali::AngleAxis *)jarg1;
12892   result = (Dali::Vector3 *)& ((arg1)->axis);
12893   jresult = (void *)result;
12894   return jresult;
12895 }
12896
12897
12898 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AngleAxis(void * jarg1) {
12899   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12900
12901   arg1 = (Dali::AngleAxis *)jarg1;
12902   {
12903     try {
12904       delete arg1;
12905     } catch (std::out_of_range& e) {
12906       {
12907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12908       };
12909     } catch (std::exception& e) {
12910       {
12911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12912       };
12913     } catch (...) {
12914       {
12915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12916       };
12917     }
12918   }
12919 }
12920
12921
12922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12923   unsigned int jresult ;
12924   Dali::AngleAxis *arg1 = 0 ;
12925   Dali::AngleAxis *arg2 = 0 ;
12926   bool result;
12927
12928   arg1 = (Dali::AngleAxis *)jarg1;
12929   if (!arg1) {
12930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12931     return 0;
12932   }
12933   arg2 = (Dali::AngleAxis *)jarg2;
12934   if (!arg2) {
12935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12936     return 0;
12937   }
12938   {
12939     try {
12940       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12948       };
12949     } catch (...) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12952       };
12953     }
12954   }
12955   jresult = result;
12956   return jresult;
12957 }
12958
12959
12960 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_INDEX_get() {
12961   int jresult ;
12962   int result;
12963
12964   result = (int)(int)Dali::Property::INVALID_INDEX;
12965   jresult = result;
12966   return jresult;
12967 }
12968
12969
12970 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_KEY_get() {
12971   int jresult ;
12972   int result;
12973
12974   result = (int)(int)Dali::Property::INVALID_KEY;
12975   jresult = result;
12976   return jresult;
12977 }
12978
12979
12980 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_COMPONENT_INDEX_get() {
12981   int jresult ;
12982   int result;
12983
12984   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12985   jresult = result;
12986   return jresult;
12987 }
12988
12989
12990 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_0(void * jarg1, int jarg2) {
12991   void * jresult ;
12992   Dali::Handle *arg1 = 0 ;
12993   Dali::Property::Index arg2 ;
12994   Dali::Property *result = 0 ;
12995
12996   arg1 = (Dali::Handle *)jarg1;
12997   if (!arg1) {
12998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12999     return 0;
13000   }
13001   arg2 = (Dali::Property::Index)jarg2;
13002   {
13003     try {
13004       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13005     } catch (std::out_of_range& e) {
13006       {
13007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13008       };
13009     } catch (std::exception& e) {
13010       {
13011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13012       };
13013     } catch (...) {
13014       {
13015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13016       };
13017     }
13018   }
13019   jresult = (void *)result;
13020   return jresult;
13021 }
13022
13023
13024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13025   void * jresult ;
13026   Dali::Handle *arg1 = 0 ;
13027   Dali::Property::Index arg2 ;
13028   int arg3 ;
13029   Dali::Property *result = 0 ;
13030
13031   arg1 = (Dali::Handle *)jarg1;
13032   if (!arg1) {
13033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13034     return 0;
13035   }
13036   arg2 = (Dali::Property::Index)jarg2;
13037   arg3 = (int)jarg3;
13038   {
13039     try {
13040       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13041     } catch (std::out_of_range& e) {
13042       {
13043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13044       };
13045     } catch (std::exception& e) {
13046       {
13047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13048       };
13049     } catch (...) {
13050       {
13051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13052       };
13053     }
13054   }
13055   jresult = (void *)result;
13056   return jresult;
13057 }
13058
13059
13060 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13061   void * jresult ;
13062   Dali::Handle *arg1 = 0 ;
13063   std::string *arg2 = 0 ;
13064   Dali::Property *result = 0 ;
13065
13066   arg1 = (Dali::Handle *)jarg1;
13067   if (!arg1) {
13068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13069     return 0;
13070   }
13071   if (!jarg2) {
13072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13073     return 0;
13074   }
13075   std::string arg2_str(jarg2);
13076   arg2 = &arg2_str;
13077   {
13078     try {
13079       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13080     } catch (std::out_of_range& e) {
13081       {
13082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13083       };
13084     } catch (std::exception& e) {
13085       {
13086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13087       };
13088     } catch (...) {
13089       {
13090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13091       };
13092     }
13093   }
13094   jresult = (void *)result;
13095
13096   //argout typemap for const std::string&
13097
13098   return jresult;
13099 }
13100
13101
13102 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13103   void * jresult ;
13104   Dali::Handle *arg1 = 0 ;
13105   std::string *arg2 = 0 ;
13106   int arg3 ;
13107   Dali::Property *result = 0 ;
13108
13109   arg1 = (Dali::Handle *)jarg1;
13110   if (!arg1) {
13111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13112     return 0;
13113   }
13114   if (!jarg2) {
13115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13116     return 0;
13117   }
13118   std::string arg2_str(jarg2);
13119   arg2 = &arg2_str;
13120   arg3 = (int)jarg3;
13121   {
13122     try {
13123       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13124     } catch (std::out_of_range& e) {
13125       {
13126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13127       };
13128     } catch (std::exception& e) {
13129       {
13130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13131       };
13132     } catch (...) {
13133       {
13134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13135       };
13136     }
13137   }
13138   jresult = (void *)result;
13139
13140   //argout typemap for const std::string&
13141
13142   return jresult;
13143 }
13144
13145
13146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property(void * jarg1) {
13147   Dali::Property *arg1 = (Dali::Property *) 0 ;
13148
13149   arg1 = (Dali::Property *)jarg1;
13150   {
13151     try {
13152       delete arg1;
13153     } catch (std::out_of_range& e) {
13154       {
13155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13156       };
13157     } catch (std::exception& e) {
13158       {
13159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13164       };
13165     }
13166   }
13167 }
13168
13169
13170 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property__object_set(void * jarg1, void * jarg2) {
13171   Dali::Property *arg1 = (Dali::Property *) 0 ;
13172   Dali::Handle *arg2 = 0 ;
13173
13174   arg1 = (Dali::Property *)jarg1;
13175   arg2 = (Dali::Handle *)jarg2;
13176   if (!arg2) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13178     return ;
13179   }
13180   if (arg1) (arg1)->object = *arg2;
13181 }
13182
13183
13184 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property__object_get(void * jarg1) {
13185   void * jresult ;
13186   Dali::Property *arg1 = (Dali::Property *) 0 ;
13187   Dali::Handle *result = 0 ;
13188
13189   arg1 = (Dali::Property *)jarg1;
13190   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13191   jresult = (void *)result;
13192   return jresult;
13193 }
13194
13195
13196 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_propertyIndex_set(void * jarg1, int jarg2) {
13197   Dali::Property *arg1 = (Dali::Property *) 0 ;
13198   Dali::Property::Index arg2 ;
13199
13200   arg1 = (Dali::Property *)jarg1;
13201   arg2 = (Dali::Property::Index)jarg2;
13202   if (arg1) (arg1)->propertyIndex = arg2;
13203 }
13204
13205
13206 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_propertyIndex_get(void * jarg1) {
13207   int jresult ;
13208   Dali::Property *arg1 = (Dali::Property *) 0 ;
13209   Dali::Property::Index result;
13210
13211   arg1 = (Dali::Property *)jarg1;
13212   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13213   jresult = result;
13214   return jresult;
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_componentIndex_set(void * jarg1, int jarg2) {
13219   Dali::Property *arg1 = (Dali::Property *) 0 ;
13220   int arg2 ;
13221
13222   arg1 = (Dali::Property *)jarg1;
13223   arg2 = (int)jarg2;
13224   if (arg1) (arg1)->componentIndex = arg2;
13225 }
13226
13227
13228 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_componentIndex_get(void * jarg1) {
13229   int jresult ;
13230   Dali::Property *arg1 = (Dali::Property *) 0 ;
13231   int result;
13232
13233   arg1 = (Dali::Property *)jarg1;
13234   result = (int) ((arg1)->componentIndex);
13235   jresult = result;
13236   return jresult;
13237 }
13238
13239
13240 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Array__SWIG_0() {
13241   void * jresult ;
13242   Dali::Property::Array *result = 0 ;
13243
13244   {
13245     try {
13246       result = (Dali::Property::Array *)new Dali::Property::Array();
13247     } catch (std::out_of_range& e) {
13248       {
13249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13250       };
13251     } catch (std::exception& e) {
13252       {
13253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13254       };
13255     } catch (...) {
13256       {
13257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13258       };
13259     }
13260   }
13261   jresult = (void *)result;
13262   return jresult;
13263 }
13264
13265
13266 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Array__SWIG_1(void * jarg1) {
13267   void * jresult ;
13268   Dali::Property::Array *arg1 = 0 ;
13269   Dali::Property::Array *result = 0 ;
13270
13271   arg1 = (Dali::Property::Array *)jarg1;
13272   if (!arg1) {
13273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13274     return 0;
13275   }
13276   {
13277     try {
13278       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13279     } catch (std::out_of_range& e) {
13280       {
13281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13282       };
13283     } catch (std::exception& e) {
13284       {
13285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13286       };
13287     } catch (...) {
13288       {
13289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13290       };
13291     }
13292   }
13293   jresult = (void *)result;
13294   return jresult;
13295 }
13296
13297
13298 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Array(void * jarg1) {
13299   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13300
13301   arg1 = (Dali::Property::Array *)jarg1;
13302   {
13303     try {
13304       delete arg1;
13305     } catch (std::out_of_range& e) {
13306       {
13307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13308       };
13309     } catch (std::exception& e) {
13310       {
13311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13312       };
13313     } catch (...) {
13314       {
13315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13316       };
13317     }
13318   }
13319 }
13320
13321
13322 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Size(void * jarg1) {
13323   unsigned long jresult ;
13324   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13325   Dali::Property::Array::SizeType result;
13326
13327   arg1 = (Dali::Property::Array *)jarg1;
13328   {
13329     try {
13330       result = ((Dali::Property::Array const *)arg1)->Size();
13331     } catch (std::out_of_range& e) {
13332       {
13333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13334       };
13335     } catch (std::exception& e) {
13336       {
13337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13338       };
13339     } catch (...) {
13340       {
13341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13342       };
13343     }
13344   }
13345   jresult = (unsigned long)result;
13346   return jresult;
13347 }
13348
13349
13350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Count(void * jarg1) {
13351   unsigned long jresult ;
13352   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13353   Dali::Property::Array::SizeType result;
13354
13355   arg1 = (Dali::Property::Array *)jarg1;
13356   {
13357     try {
13358       result = ((Dali::Property::Array const *)arg1)->Count();
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13366       };
13367     } catch (...) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13370       };
13371     }
13372   }
13373   jresult = (unsigned long)result;
13374   return jresult;
13375 }
13376
13377
13378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Array_Empty(void * jarg1) {
13379   unsigned int jresult ;
13380   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13381   bool result;
13382
13383   arg1 = (Dali::Property::Array *)jarg1;
13384   {
13385     try {
13386       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13387     } catch (std::out_of_range& e) {
13388       {
13389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13390       };
13391     } catch (std::exception& e) {
13392       {
13393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13394       };
13395     } catch (...) {
13396       {
13397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13398       };
13399     }
13400   }
13401   jresult = result;
13402   return jresult;
13403 }
13404
13405
13406 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Clear(void * jarg1) {
13407   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13408
13409   arg1 = (Dali::Property::Array *)jarg1;
13410   {
13411     try {
13412       (arg1)->Clear();
13413     } catch (std::out_of_range& e) {
13414       {
13415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13416       };
13417     } catch (std::exception& e) {
13418       {
13419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13420       };
13421     } catch (...) {
13422       {
13423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13424       };
13425     }
13426   }
13427 }
13428
13429
13430 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13431   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13432   Dali::Property::Array::SizeType arg2 ;
13433
13434   arg1 = (Dali::Property::Array *)jarg1;
13435   arg2 = (Dali::Property::Array::SizeType)jarg2;
13436   {
13437     try {
13438       (arg1)->Reserve(arg2);
13439     } catch (std::out_of_range& e) {
13440       {
13441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13442       };
13443     } catch (std::exception& e) {
13444       {
13445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13446       };
13447     } catch (...) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13450       };
13451     }
13452   }
13453 }
13454
13455
13456 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13457   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13458   Dali::Property::Array::SizeType arg2 ;
13459
13460   arg1 = (Dali::Property::Array *)jarg1;
13461   arg2 = (Dali::Property::Array::SizeType)jarg2;
13462   {
13463     try {
13464       (arg1)->Resize(arg2);
13465     } catch (std::out_of_range& e) {
13466       {
13467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13468       };
13469     } catch (std::exception& e) {
13470       {
13471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13472       };
13473     } catch (...) {
13474       {
13475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13476       };
13477     }
13478   }
13479 }
13480
13481
13482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Capacity(void * jarg1) {
13483   unsigned long jresult ;
13484   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13485   Dali::Property::Array::SizeType result;
13486
13487   arg1 = (Dali::Property::Array *)jarg1;
13488   {
13489     try {
13490       result = (arg1)->Capacity();
13491     } catch (std::out_of_range& e) {
13492       {
13493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13494       };
13495     } catch (std::exception& e) {
13496       {
13497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13498       };
13499     } catch (...) {
13500       {
13501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13502       };
13503     }
13504   }
13505   jresult = (unsigned long)result;
13506   return jresult;
13507 }
13508
13509
13510 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_PushBack(void * jarg1, void * jarg2) {
13511   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13512   Dali::Property::Value *arg2 = 0 ;
13513
13514   arg1 = (Dali::Property::Array *)jarg1;
13515   arg2 = (Dali::Property::Value *)jarg2;
13516   if (!arg2) {
13517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13518     return ;
13519   }
13520   {
13521     try {
13522       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13523     } catch (std::out_of_range& e) {
13524       {
13525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13526       };
13527     } catch (std::exception& e) {
13528       {
13529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13530       };
13531     } catch (...) {
13532       {
13533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13534       };
13535     }
13536   }
13537 }
13538
13539
13540 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_Add(void * jarg1, void * jarg2) {
13541   void * jresult ;
13542   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13543   Dali::Property::Value *arg2 = 0 ;
13544   Dali::Property::Array *result = 0 ;
13545
13546   arg1 = (Dali::Property::Array *)jarg1;
13547   arg2 = (Dali::Property::Value *)jarg2;
13548   if (!arg2) {
13549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13550     return 0;
13551   }
13552   {
13553     try {
13554       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13555     } catch (std::out_of_range& e) {
13556       {
13557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13558       };
13559     } catch (std::exception& e) {
13560       {
13561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13562       };
13563     } catch (...) {
13564       {
13565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13566       };
13567     }
13568   }
13569   jresult = (void *)result;
13570   return jresult;
13571 }
13572
13573
13574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13575   void * jresult ;
13576   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13577   Dali::Property::Array::SizeType arg2 ;
13578   Dali::Property::Value *result = 0 ;
13579
13580   arg1 = (Dali::Property::Array *)jarg1;
13581   arg2 = (Dali::Property::Array::SizeType)jarg2;
13582   {
13583     try {
13584       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13585     } catch (std::out_of_range& e) {
13586       {
13587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13588       };
13589     } catch (std::exception& e) {
13590       {
13591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13592       };
13593     } catch (...) {
13594       {
13595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13596       };
13597     }
13598   }
13599   jresult = (void *)result;
13600   return jresult;
13601 }
13602
13603
13604 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13605   void * jresult ;
13606   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13607   Dali::Property::Array::SizeType arg2 ;
13608   Dali::Property::Value *result = 0 ;
13609
13610   arg1 = (Dali::Property::Array *)jarg1;
13611   arg2 = (Dali::Property::Array::SizeType)jarg2;
13612   {
13613     try {
13614       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (...) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13626       };
13627     }
13628   }
13629   jresult = (void *)result;
13630   return jresult;
13631 }
13632
13633
13634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_Assign(void * jarg1, void * jarg2) {
13635   void * jresult ;
13636   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13637   Dali::Property::Array *arg2 = 0 ;
13638   Dali::Property::Array *result = 0 ;
13639
13640   arg1 = (Dali::Property::Array *)jarg1;
13641   arg2 = (Dali::Property::Array *)jarg2;
13642   if (!arg2) {
13643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13644     return 0;
13645   }
13646   {
13647     try {
13648       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13649     } catch (std::out_of_range& e) {
13650       {
13651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13652       };
13653     } catch (std::exception& e) {
13654       {
13655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13656       };
13657     } catch (...) {
13658       {
13659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13660       };
13661     }
13662   }
13663   jresult = (void *)result;
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_type_set(void * jarg1, int jarg2) {
13669   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13670   enum Dali::Property::Key::Type arg2 ;
13671
13672   arg1 = (Dali::Property::Key *)jarg1;
13673   arg2 = (enum Dali::Property::Key::Type)jarg2;
13674   if (arg1) (arg1)->type = arg2;
13675 }
13676
13677
13678 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Key_type_get(void * jarg1) {
13679   int jresult ;
13680   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13681   enum Dali::Property::Key::Type result;
13682
13683   arg1 = (Dali::Property::Key *)jarg1;
13684   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13685   jresult = (int)result;
13686   return jresult;
13687 }
13688
13689
13690 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13691   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13692   Dali::Property::Index arg2 ;
13693
13694   arg1 = (Dali::Property::Key *)jarg1;
13695   arg2 = (Dali::Property::Index)jarg2;
13696   if (arg1) (arg1)->indexKey = arg2;
13697 }
13698
13699
13700 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Key_indexKey_get(void * jarg1) {
13701   int jresult ;
13702   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13703   Dali::Property::Index result;
13704
13705   arg1 = (Dali::Property::Key *)jarg1;
13706   result = (Dali::Property::Index) ((arg1)->indexKey);
13707   jresult = result;
13708   return jresult;
13709 }
13710
13711
13712 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13713   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13714   std::string *arg2 = 0 ;
13715
13716   arg1 = (Dali::Property::Key *)jarg1;
13717   if (!jarg2) {
13718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13719     return ;
13720   }
13721   std::string arg2_str(jarg2);
13722   arg2 = &arg2_str;
13723   if (arg1) (arg1)->stringKey = *arg2;
13724
13725   //argout typemap for const std::string&
13726
13727 }
13728
13729
13730 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Property_Key_stringKey_get(void * jarg1) {
13731   char * jresult ;
13732   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13733   std::string *result = 0 ;
13734
13735   arg1 = (Dali::Property::Key *)jarg1;
13736   result = (std::string *) & ((arg1)->stringKey);
13737   jresult = SWIG_csharp_string_callback(result->c_str());
13738   return jresult;
13739 }
13740
13741
13742 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Key__SWIG_0(char * jarg1) {
13743   void * jresult ;
13744   std::string *arg1 = 0 ;
13745   Dali::Property::Key *result = 0 ;
13746
13747   if (!jarg1) {
13748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13749     return 0;
13750   }
13751   std::string arg1_str(jarg1);
13752   arg1 = &arg1_str;
13753   {
13754     try {
13755       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13756     } catch (std::out_of_range& e) {
13757       {
13758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13759       };
13760     } catch (std::exception& e) {
13761       {
13762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13763       };
13764     } catch (...) {
13765       {
13766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13767       };
13768     }
13769   }
13770   jresult = (void *)result;
13771
13772   //argout typemap for const std::string&
13773
13774   return jresult;
13775 }
13776
13777
13778 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Key__SWIG_1(int jarg1) {
13779   void * jresult ;
13780   Dali::Property::Index arg1 ;
13781   Dali::Property::Key *result = 0 ;
13782
13783   arg1 = (Dali::Property::Index)jarg1;
13784   {
13785     try {
13786       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13787     } catch (std::out_of_range& e) {
13788       {
13789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (std::exception& e) {
13792       {
13793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13794       };
13795     } catch (...) {
13796       {
13797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13798       };
13799     }
13800   }
13801   jresult = (void *)result;
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13807   unsigned int jresult ;
13808   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13809   std::string *arg2 = 0 ;
13810   bool result;
13811
13812   arg1 = (Dali::Property::Key *)jarg1;
13813   if (!jarg2) {
13814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13815     return 0;
13816   }
13817   std::string arg2_str(jarg2);
13818   arg2 = &arg2_str;
13819   {
13820     try {
13821       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13822     } catch (std::out_of_range& e) {
13823       {
13824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (std::exception& e) {
13827       {
13828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13829       };
13830     } catch (...) {
13831       {
13832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13833       };
13834     }
13835   }
13836   jresult = result;
13837
13838   //argout typemap for const std::string&
13839
13840   return jresult;
13841 }
13842
13843
13844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13845   unsigned int jresult ;
13846   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13847   Dali::Property::Index arg2 ;
13848   bool result;
13849
13850   arg1 = (Dali::Property::Key *)jarg1;
13851   arg2 = (Dali::Property::Index)jarg2;
13852   {
13853     try {
13854       result = (bool)(arg1)->operator ==(arg2);
13855     } catch (std::out_of_range& e) {
13856       {
13857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (std::exception& e) {
13860       {
13861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13862       };
13863     } catch (...) {
13864       {
13865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13866       };
13867     }
13868   }
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13875   unsigned int jresult ;
13876   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13877   Dali::Property::Key *arg2 = 0 ;
13878   bool result;
13879
13880   arg1 = (Dali::Property::Key *)jarg1;
13881   arg2 = (Dali::Property::Key *)jarg2;
13882   if (!arg2) {
13883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13884     return 0;
13885   }
13886   {
13887     try {
13888       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13889     } catch (std::out_of_range& e) {
13890       {
13891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13892       };
13893     } catch (std::exception& e) {
13894       {
13895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13896       };
13897     } catch (...) {
13898       {
13899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13900       };
13901     }
13902   }
13903   jresult = result;
13904   return jresult;
13905 }
13906
13907
13908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13909   unsigned int jresult ;
13910   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13911   std::string *arg2 = 0 ;
13912   bool result;
13913
13914   arg1 = (Dali::Property::Key *)jarg1;
13915   if (!jarg2) {
13916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13917     return 0;
13918   }
13919   std::string arg2_str(jarg2);
13920   arg2 = &arg2_str;
13921   {
13922     try {
13923       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13924     } catch (std::out_of_range& e) {
13925       {
13926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13927       };
13928     } catch (std::exception& e) {
13929       {
13930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13931       };
13932     } catch (...) {
13933       {
13934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13935       };
13936     }
13937   }
13938   jresult = result;
13939
13940   //argout typemap for const std::string&
13941
13942   return jresult;
13943 }
13944
13945
13946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13947   unsigned int jresult ;
13948   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13949   Dali::Property::Index arg2 ;
13950   bool result;
13951
13952   arg1 = (Dali::Property::Key *)jarg1;
13953   arg2 = (Dali::Property::Index)jarg2;
13954   {
13955     try {
13956       result = (bool)(arg1)->operator !=(arg2);
13957     } catch (std::out_of_range& e) {
13958       {
13959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13960       };
13961     } catch (std::exception& e) {
13962       {
13963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13964       };
13965     } catch (...) {
13966       {
13967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13968       };
13969     }
13970   }
13971   jresult = result;
13972   return jresult;
13973 }
13974
13975
13976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13977   unsigned int jresult ;
13978   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13979   Dali::Property::Key *arg2 = 0 ;
13980   bool result;
13981
13982   arg1 = (Dali::Property::Key *)jarg1;
13983   arg2 = (Dali::Property::Key *)jarg2;
13984   if (!arg2) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13986     return 0;
13987   }
13988   {
13989     try {
13990       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13998       };
13999     } catch (...) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14002       };
14003     }
14004   }
14005   jresult = result;
14006   return jresult;
14007 }
14008
14009
14010 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Key(void * jarg1) {
14011   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14012
14013   arg1 = (Dali::Property::Key *)jarg1;
14014   {
14015     try {
14016       delete arg1;
14017     } catch (std::out_of_range& e) {
14018       {
14019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14020       };
14021     } catch (std::exception& e) {
14022       {
14023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14024       };
14025     } catch (...) {
14026       {
14027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14028       };
14029     }
14030   }
14031 }
14032
14033
14034 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Map__SWIG_0() {
14035   void * jresult ;
14036   Dali::Property::Map *result = 0 ;
14037
14038   {
14039     try {
14040       result = (Dali::Property::Map *)new Dali::Property::Map();
14041     } catch (std::out_of_range& e) {
14042       {
14043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14044       };
14045     } catch (std::exception& e) {
14046       {
14047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14048       };
14049     } catch (...) {
14050       {
14051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14052       };
14053     }
14054   }
14055   jresult = (void *)result;
14056   return jresult;
14057 }
14058
14059
14060 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Map__SWIG_1(void * jarg1) {
14061   void * jresult ;
14062   Dali::Property::Map *arg1 = 0 ;
14063   Dali::Property::Map *result = 0 ;
14064
14065   arg1 = (Dali::Property::Map *)jarg1;
14066   if (!arg1) {
14067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14068     return 0;
14069   }
14070   {
14071     try {
14072       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14073     } catch (std::out_of_range& e) {
14074       {
14075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14076       };
14077     } catch (std::exception& e) {
14078       {
14079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14080       };
14081     } catch (...) {
14082       {
14083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14084       };
14085     }
14086   }
14087   jresult = (void *)result;
14088   return jresult;
14089 }
14090
14091
14092 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Map(void * jarg1) {
14093   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14094
14095   arg1 = (Dali::Property::Map *)jarg1;
14096   {
14097     try {
14098       delete arg1;
14099     } catch (std::out_of_range& e) {
14100       {
14101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14102       };
14103     } catch (std::exception& e) {
14104       {
14105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14106       };
14107     } catch (...) {
14108       {
14109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14110       };
14111     }
14112   }
14113 }
14114
14115
14116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Map_Count(void * jarg1) {
14117   unsigned long jresult ;
14118   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14119   Dali::Property::Map::SizeType result;
14120
14121   arg1 = (Dali::Property::Map *)jarg1;
14122   {
14123     try {
14124       result = ((Dali::Property::Map const *)arg1)->Count();
14125     } catch (std::out_of_range& e) {
14126       {
14127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14128       };
14129     } catch (std::exception& e) {
14130       {
14131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14132       };
14133     } catch (...) {
14134       {
14135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14136       };
14137     }
14138   }
14139   jresult = (unsigned long)result;
14140   return jresult;
14141 }
14142
14143
14144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Map_Empty(void * jarg1) {
14145   unsigned int jresult ;
14146   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14147   bool result;
14148
14149   arg1 = (Dali::Property::Map *)jarg1;
14150   {
14151     try {
14152       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14153     } catch (std::out_of_range& e) {
14154       {
14155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14156       };
14157     } catch (std::exception& e) {
14158       {
14159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14160       };
14161     } catch (...) {
14162       {
14163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14164       };
14165     }
14166   }
14167   jresult = result;
14168   return jresult;
14169 }
14170
14171
14172 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14173   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14174   char *arg2 = (char *) 0 ;
14175   Dali::Property::Value *arg3 = 0 ;
14176
14177   arg1 = (Dali::Property::Map *)jarg1;
14178   arg2 = (char *)jarg2;
14179   arg3 = (Dali::Property::Value *)jarg3;
14180   if (!arg3) {
14181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14182     return ;
14183   }
14184   {
14185     try {
14186       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14187     } catch (std::out_of_range& e) {
14188       {
14189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14190       };
14191     } catch (std::exception& e) {
14192       {
14193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14194       };
14195     } catch (...) {
14196       {
14197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14198       };
14199     }
14200   }
14201 }
14202
14203
14204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14205   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14206   Dali::Property::Index arg2 ;
14207   Dali::Property::Value *arg3 = 0 ;
14208
14209   arg1 = (Dali::Property::Map *)jarg1;
14210   arg2 = (Dali::Property::Index)jarg2;
14211   arg3 = (Dali::Property::Value *)jarg3;
14212   if (!arg3) {
14213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14214     return ;
14215   }
14216   {
14217     try {
14218       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14219     } catch (std::out_of_range& e) {
14220       {
14221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14222       };
14223     } catch (std::exception& e) {
14224       {
14225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14226       };
14227     } catch (...) {
14228       {
14229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14230       };
14231     }
14232   }
14233 }
14234
14235
14236 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14237   void * jresult ;
14238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14239   char *arg2 = (char *) 0 ;
14240   Dali::Property::Value *arg3 = 0 ;
14241   Dali::Property::Map *result = 0 ;
14242
14243   arg1 = (Dali::Property::Map *)jarg1;
14244   arg2 = (char *)jarg2;
14245   arg3 = (Dali::Property::Value *)jarg3;
14246   if (!arg3) {
14247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14248     return 0;
14249   }
14250   {
14251     try {
14252       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14253     } catch (std::out_of_range& e) {
14254       {
14255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14256       };
14257     } catch (std::exception& e) {
14258       {
14259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14260       };
14261     } catch (...) {
14262       {
14263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14264       };
14265     }
14266   }
14267   jresult = (void *)result;
14268   return jresult;
14269 }
14270
14271
14272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14273   void * jresult ;
14274   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14275   Dali::Property::Index arg2 ;
14276   Dali::Property::Value *arg3 = 0 ;
14277   Dali::Property::Map *result = 0 ;
14278
14279   arg1 = (Dali::Property::Map *)jarg1;
14280   arg2 = (Dali::Property::Index)jarg2;
14281   arg3 = (Dali::Property::Value *)jarg3;
14282   if (!arg3) {
14283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14284     return 0;
14285   }
14286   {
14287     try {
14288       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14289     } catch (std::out_of_range& e) {
14290       {
14291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14292       };
14293     } catch (std::exception& e) {
14294       {
14295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14296       };
14297     } catch (...) {
14298       {
14299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14300       };
14301     }
14302   }
14303   jresult = (void *)result;
14304   return jresult;
14305 }
14306
14307
14308 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14309   void * jresult ;
14310   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14311   Dali::Property::Map::SizeType arg2 ;
14312   Dali::Property::Value *result = 0 ;
14313
14314   arg1 = (Dali::Property::Map *)jarg1;
14315   arg2 = (Dali::Property::Map::SizeType)jarg2;
14316   {
14317     try {
14318       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14319     } catch (std::out_of_range& e) {
14320       {
14321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14322       };
14323     } catch (std::exception& e) {
14324       {
14325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14326       };
14327     } catch (...) {
14328       {
14329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14330       };
14331     }
14332   }
14333   jresult = (void *)result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14339   char * jresult ;
14340   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14341   Dali::Property::Map::SizeType arg2 ;
14342   std::string *result = 0 ;
14343
14344   arg1 = (Dali::Property::Map *)jarg1;
14345   arg2 = (Dali::Property::Map::SizeType)jarg2;
14346   {
14347     try {
14348       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (...) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14360       };
14361     }
14362   }
14363   jresult = SWIG_csharp_string_callback(result->c_str());
14364   return jresult;
14365 }
14366
14367
14368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14369   void * jresult ;
14370   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14371   Dali::Property::Map::SizeType arg2 ;
14372   SwigValueWrapper< Dali::Property::Key > result;
14373
14374   arg1 = (Dali::Property::Map *)jarg1;
14375   arg2 = (Dali::Property::Map::SizeType)jarg2;
14376   {
14377     try {
14378       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14379     } catch (std::out_of_range& e) {
14380       {
14381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14382       };
14383     } catch (std::exception& e) {
14384       {
14385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14386       };
14387     } catch (...) {
14388       {
14389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14390       };
14391     }
14392   }
14393   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14394   return jresult;
14395 }
14396
14397
14398 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14399   void * jresult ;
14400   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14401   Dali::Property::Map::SizeType arg2 ;
14402   StringValuePair *result = 0 ;
14403
14404   arg1 = (Dali::Property::Map *)jarg1;
14405   arg2 = (Dali::Property::Map::SizeType)jarg2;
14406   {
14407     try {
14408       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14409     } catch (std::out_of_range& e) {
14410       {
14411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14412       };
14413     } catch (std::exception& e) {
14414       {
14415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14416       };
14417     } catch (...) {
14418       {
14419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14420       };
14421     }
14422   }
14423   jresult = (void *)result;
14424   return jresult;
14425 }
14426
14427
14428 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14429   void * jresult ;
14430   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14431   char *arg2 = (char *) 0 ;
14432   Dali::Property::Value *result = 0 ;
14433
14434   arg1 = (Dali::Property::Map *)jarg1;
14435   arg2 = (char *)jarg2;
14436   {
14437     try {
14438       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14439     } catch (std::out_of_range& e) {
14440       {
14441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14442       };
14443     } catch (std::exception& e) {
14444       {
14445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14446       };
14447     } catch (...) {
14448       {
14449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14450       };
14451     }
14452   }
14453   jresult = (void *)result;
14454   return jresult;
14455 }
14456
14457
14458 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14459   void * jresult ;
14460   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14461   Dali::Property::Index arg2 ;
14462   Dali::Property::Value *result = 0 ;
14463
14464   arg1 = (Dali::Property::Map *)jarg1;
14465   arg2 = (Dali::Property::Index)jarg2;
14466   {
14467     try {
14468       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14469     } catch (std::out_of_range& e) {
14470       {
14471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14472       };
14473     } catch (std::exception& e) {
14474       {
14475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14476       };
14477     } catch (...) {
14478       {
14479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14480       };
14481     }
14482   }
14483   jresult = (void *)result;
14484   return jresult;
14485 }
14486
14487
14488 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14489   void * jresult ;
14490   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14491   Dali::Property::Index arg2 ;
14492   std::string *arg3 = 0 ;
14493   Dali::Property::Value *result = 0 ;
14494
14495   arg1 = (Dali::Property::Map *)jarg1;
14496   arg2 = (Dali::Property::Index)jarg2;
14497   if (!jarg3) {
14498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14499     return 0;
14500   }
14501   std::string arg3_str(jarg3);
14502   arg3 = &arg3_str;
14503   {
14504     try {
14505       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14506     } catch (std::out_of_range& e) {
14507       {
14508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14509       };
14510     } catch (std::exception& e) {
14511       {
14512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14513       };
14514     } catch (...) {
14515       {
14516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14517       };
14518     }
14519   }
14520   jresult = (void *)result;
14521
14522   //argout typemap for const std::string&
14523
14524   return jresult;
14525 }
14526
14527
14528 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14529   void * jresult ;
14530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14531   std::string *arg2 = 0 ;
14532   Dali::Property::Type arg3 ;
14533   Dali::Property::Value *result = 0 ;
14534
14535   arg1 = (Dali::Property::Map *)jarg1;
14536   if (!jarg2) {
14537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14538     return 0;
14539   }
14540   std::string arg2_str(jarg2);
14541   arg2 = &arg2_str;
14542   arg3 = (Dali::Property::Type)jarg3;
14543   {
14544     try {
14545       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14546     } catch (std::out_of_range& e) {
14547       {
14548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14549       };
14550     } catch (std::exception& e) {
14551       {
14552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14553       };
14554     } catch (...) {
14555       {
14556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14557       };
14558     }
14559   }
14560   jresult = (void *)result;
14561
14562   //argout typemap for const std::string&
14563
14564   return jresult;
14565 }
14566
14567
14568 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14569   void * jresult ;
14570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14571   Dali::Property::Index arg2 ;
14572   Dali::Property::Type arg3 ;
14573   Dali::Property::Value *result = 0 ;
14574
14575   arg1 = (Dali::Property::Map *)jarg1;
14576   arg2 = (Dali::Property::Index)jarg2;
14577   arg3 = (Dali::Property::Type)jarg3;
14578   {
14579     try {
14580       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14581     } catch (std::out_of_range& e) {
14582       {
14583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14584       };
14585     } catch (std::exception& e) {
14586       {
14587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14588       };
14589     } catch (...) {
14590       {
14591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14592       };
14593     }
14594   }
14595   jresult = (void *)result;
14596   return jresult;
14597 }
14598
14599
14600 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Clear(void * jarg1) {
14601   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14602
14603   arg1 = (Dali::Property::Map *)jarg1;
14604   {
14605     try {
14606       (arg1)->Clear();
14607     } catch (std::out_of_range& e) {
14608       {
14609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14610       };
14611     } catch (std::exception& e) {
14612       {
14613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14614       };
14615     } catch (...) {
14616       {
14617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14618       };
14619     }
14620   }
14621 }
14622
14623
14624 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Merge(void * jarg1, void * jarg2) {
14625   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14626   Dali::Property::Map *arg2 = 0 ;
14627
14628   arg1 = (Dali::Property::Map *)jarg1;
14629   arg2 = (Dali::Property::Map *)jarg2;
14630   if (!arg2) {
14631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14632     return ;
14633   }
14634   {
14635     try {
14636       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14637     } catch (std::out_of_range& e) {
14638       {
14639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14640       };
14641     } catch (std::exception& e) {
14642       {
14643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14644       };
14645     } catch (...) {
14646       {
14647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14648       };
14649     }
14650   }
14651 }
14652
14653
14654 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14655   void * jresult ;
14656   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14657   std::string *arg2 = 0 ;
14658   Dali::Property::Value *result = 0 ;
14659
14660   arg1 = (Dali::Property::Map *)jarg1;
14661   if (!jarg2) {
14662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14663     return 0;
14664   }
14665   std::string arg2_str(jarg2);
14666   arg2 = &arg2_str;
14667   {
14668     try {
14669       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14670     } catch (std::out_of_range& e) {
14671       {
14672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14673       };
14674     } catch (std::exception& e) {
14675       {
14676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (...) {
14679       {
14680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14681       };
14682     }
14683   }
14684   jresult = (void *)result;
14685
14686   //argout typemap for const std::string&
14687
14688   return jresult;
14689 }
14690
14691
14692 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14693   void * jresult ;
14694   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14695   Dali::Property::Index arg2 ;
14696   Dali::Property::Value *result = 0 ;
14697
14698   arg1 = (Dali::Property::Map *)jarg1;
14699   arg2 = (Dali::Property::Index)jarg2;
14700   {
14701     try {
14702       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14703     } catch (std::out_of_range& e) {
14704       {
14705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14706       };
14707     } catch (std::exception& e) {
14708       {
14709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14710       };
14711     } catch (...) {
14712       {
14713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14714       };
14715     }
14716   }
14717   jresult = (void *)result;
14718   return jresult;
14719 }
14720
14721
14722 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Assign(void * jarg1, void * jarg2) {
14723   void * jresult ;
14724   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14725   Dali::Property::Map *arg2 = 0 ;
14726   Dali::Property::Map *result = 0 ;
14727
14728   arg1 = (Dali::Property::Map *)jarg1;
14729   arg2 = (Dali::Property::Map *)jarg2;
14730   if (!arg2) {
14731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14732     return 0;
14733   }
14734   {
14735     try {
14736       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14737     } catch (std::out_of_range& e) {
14738       {
14739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (std::exception& e) {
14742       {
14743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14744       };
14745     } catch (...) {
14746       {
14747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14748       };
14749     }
14750   }
14751   jresult = (void *)result;
14752   return jresult;
14753 }
14754
14755
14756 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_0() {
14757   void * jresult ;
14758   Dali::Property::Value *result = 0 ;
14759
14760   {
14761     try {
14762       result = (Dali::Property::Value *)new Dali::Property::Value();
14763     } catch (std::out_of_range& e) {
14764       {
14765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14766       };
14767     } catch (std::exception& e) {
14768       {
14769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (...) {
14772       {
14773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14774       };
14775     }
14776   }
14777   jresult = (void *)result;
14778   return jresult;
14779 }
14780
14781
14782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_1(unsigned int jarg1) {
14783   void * jresult ;
14784   bool arg1 ;
14785   Dali::Property::Value *result = 0 ;
14786
14787   arg1 = jarg1 ? true : false;
14788   {
14789     try {
14790       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14791     } catch (std::out_of_range& e) {
14792       {
14793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14794       };
14795     } catch (std::exception& e) {
14796       {
14797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14798       };
14799     } catch (...) {
14800       {
14801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14802       };
14803     }
14804   }
14805   jresult = (void *)result;
14806   return jresult;
14807 }
14808
14809
14810 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_2(int jarg1) {
14811   void * jresult ;
14812   int arg1 ;
14813   Dali::Property::Value *result = 0 ;
14814
14815   arg1 = (int)jarg1;
14816   {
14817     try {
14818       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14819     } catch (std::out_of_range& e) {
14820       {
14821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14822       };
14823     } catch (std::exception& e) {
14824       {
14825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14826       };
14827     } catch (...) {
14828       {
14829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14830       };
14831     }
14832   }
14833   jresult = (void *)result;
14834   return jresult;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_3(float jarg1) {
14839   void * jresult ;
14840   float arg1 ;
14841   Dali::Property::Value *result = 0 ;
14842
14843   arg1 = (float)jarg1;
14844   {
14845     try {
14846       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14847     } catch (std::out_of_range& e) {
14848       {
14849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14850       };
14851     } catch (std::exception& e) {
14852       {
14853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14854       };
14855     } catch (...) {
14856       {
14857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14858       };
14859     }
14860   }
14861   jresult = (void *)result;
14862   return jresult;
14863 }
14864
14865
14866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_4(void * jarg1) {
14867   void * jresult ;
14868   Dali::Vector2 *arg1 = 0 ;
14869   Dali::Property::Value *result = 0 ;
14870
14871   arg1 = (Dali::Vector2 *)jarg1;
14872   if (!arg1) {
14873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14874     return 0;
14875   }
14876   {
14877     try {
14878       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14879     } catch (std::out_of_range& e) {
14880       {
14881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14882       };
14883     } catch (std::exception& e) {
14884       {
14885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14886       };
14887     } catch (...) {
14888       {
14889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14890       };
14891     }
14892   }
14893   jresult = (void *)result;
14894   return jresult;
14895 }
14896
14897
14898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_5(void * jarg1) {
14899   void * jresult ;
14900   Dali::Vector3 *arg1 = 0 ;
14901   Dali::Property::Value *result = 0 ;
14902
14903   arg1 = (Dali::Vector3 *)jarg1;
14904   if (!arg1) {
14905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14906     return 0;
14907   }
14908   {
14909     try {
14910       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14911     } catch (std::out_of_range& e) {
14912       {
14913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14914       };
14915     } catch (std::exception& e) {
14916       {
14917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14918       };
14919     } catch (...) {
14920       {
14921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14922       };
14923     }
14924   }
14925   jresult = (void *)result;
14926   return jresult;
14927 }
14928
14929
14930 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_6(void * jarg1) {
14931   void * jresult ;
14932   Dali::Vector4 *arg1 = 0 ;
14933   Dali::Property::Value *result = 0 ;
14934
14935   arg1 = (Dali::Vector4 *)jarg1;
14936   if (!arg1) {
14937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14938     return 0;
14939   }
14940   {
14941     try {
14942       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14943     } catch (std::out_of_range& e) {
14944       {
14945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14946       };
14947     } catch (std::exception& e) {
14948       {
14949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14950       };
14951     } catch (...) {
14952       {
14953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14954       };
14955     }
14956   }
14957   jresult = (void *)result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_7(void * jarg1) {
14963   void * jresult ;
14964   Dali::Matrix3 *arg1 = 0 ;
14965   Dali::Property::Value *result = 0 ;
14966
14967   arg1 = (Dali::Matrix3 *)jarg1;
14968   if (!arg1) {
14969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14970     return 0;
14971   }
14972   {
14973     try {
14974       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14975     } catch (std::out_of_range& e) {
14976       {
14977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14978       };
14979     } catch (std::exception& e) {
14980       {
14981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14986       };
14987     }
14988   }
14989   jresult = (void *)result;
14990   return jresult;
14991 }
14992
14993
14994 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_8(void * jarg1) {
14995   void * jresult ;
14996   Dali::Matrix *arg1 = 0 ;
14997   Dali::Property::Value *result = 0 ;
14998
14999   arg1 = (Dali::Matrix *)jarg1;
15000   if (!arg1) {
15001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15002     return 0;
15003   }
15004   {
15005     try {
15006       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15007     } catch (std::out_of_range& e) {
15008       {
15009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15010       };
15011     } catch (std::exception& e) {
15012       {
15013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15014       };
15015     } catch (...) {
15016       {
15017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15018       };
15019     }
15020   }
15021   jresult = (void *)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_9(void * jarg1) {
15027   void * jresult ;
15028   Dali::Rect< int > *arg1 = 0 ;
15029   Dali::Property::Value *result = 0 ;
15030
15031   arg1 = (Dali::Rect< int > *)jarg1;
15032   if (!arg1) {
15033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15034     return 0;
15035   }
15036   {
15037     try {
15038       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15039     } catch (std::out_of_range& e) {
15040       {
15041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (std::exception& e) {
15044       {
15045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053   jresult = (void *)result;
15054   return jresult;
15055 }
15056
15057
15058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_10(void * jarg1) {
15059   void * jresult ;
15060   Dali::AngleAxis *arg1 = 0 ;
15061   Dali::Property::Value *result = 0 ;
15062
15063   arg1 = (Dali::AngleAxis *)jarg1;
15064   if (!arg1) {
15065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15066     return 0;
15067   }
15068   {
15069     try {
15070       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15071     } catch (std::out_of_range& e) {
15072       {
15073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15074       };
15075     } catch (std::exception& e) {
15076       {
15077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15078       };
15079     } catch (...) {
15080       {
15081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15082       };
15083     }
15084   }
15085   jresult = (void *)result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_11(void * jarg1) {
15091   void * jresult ;
15092   Dali::Quaternion *arg1 = 0 ;
15093   Dali::Property::Value *result = 0 ;
15094
15095   arg1 = (Dali::Quaternion *)jarg1;
15096   if (!arg1) {
15097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15098     return 0;
15099   }
15100   {
15101     try {
15102       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15103     } catch (std::out_of_range& e) {
15104       {
15105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15106       };
15107     } catch (std::exception& e) {
15108       {
15109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15114       };
15115     }
15116   }
15117   jresult = (void *)result;
15118   return jresult;
15119 }
15120
15121
15122 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_12(char * jarg1) {
15123   void * jresult ;
15124   std::string *arg1 = 0 ;
15125   Dali::Property::Value *result = 0 ;
15126
15127   if (!jarg1) {
15128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15129     return 0;
15130   }
15131   std::string arg1_str(jarg1);
15132   arg1 = &arg1_str;
15133   {
15134     try {
15135       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15136     } catch (std::out_of_range& e) {
15137       {
15138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15139       };
15140     } catch (std::exception& e) {
15141       {
15142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15143       };
15144     } catch (...) {
15145       {
15146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15147       };
15148     }
15149   }
15150   jresult = (void *)result;
15151
15152   //argout typemap for const std::string&
15153
15154   return jresult;
15155 }
15156
15157
15158 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_14(void * jarg1) {
15159   void * jresult ;
15160   Dali::Property::Array *arg1 = 0 ;
15161   Dali::Property::Value *result = 0 ;
15162
15163   arg1 = (Dali::Property::Array *)jarg1;
15164   if (!arg1) {
15165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15166     return 0;
15167   }
15168   {
15169     try {
15170       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15171     } catch (std::out_of_range& e) {
15172       {
15173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15174       };
15175     } catch (std::exception& e) {
15176       {
15177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15178       };
15179     } catch (...) {
15180       {
15181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15182       };
15183     }
15184   }
15185   jresult = (void *)result;
15186   return jresult;
15187 }
15188
15189
15190 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_15(void * jarg1) {
15191   void * jresult ;
15192   Dali::Property::Map *arg1 = 0 ;
15193   Dali::Property::Value *result = 0 ;
15194
15195   arg1 = (Dali::Property::Map *)jarg1;
15196   if (!arg1) {
15197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15198     return 0;
15199   }
15200   {
15201     try {
15202       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15203     } catch (std::out_of_range& e) {
15204       {
15205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15206       };
15207     } catch (std::exception& e) {
15208       {
15209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15210       };
15211     } catch (...) {
15212       {
15213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15214       };
15215     }
15216   }
15217   jresult = (void *)result;
15218   return jresult;
15219 }
15220
15221
15222 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_16(int jarg1) {
15223   void * jresult ;
15224   Dali::Property::Type arg1 ;
15225   Dali::Property::Value *result = 0 ;
15226
15227   arg1 = (Dali::Property::Type)jarg1;
15228   {
15229     try {
15230       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15231     } catch (std::out_of_range& e) {
15232       {
15233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15234       };
15235     } catch (std::exception& e) {
15236       {
15237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15242       };
15243     }
15244   }
15245   jresult = (void *)result;
15246   return jresult;
15247 }
15248
15249
15250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_17(void * jarg1) {
15251   void * jresult ;
15252   Dali::Property::Value *arg1 = 0 ;
15253   Dali::Property::Value *result = 0 ;
15254
15255   arg1 = (Dali::Property::Value *)jarg1;
15256   if (!arg1) {
15257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15258     return 0;
15259   }
15260   {
15261     try {
15262       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (...) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15274       };
15275     }
15276   }
15277   jresult = (void *)result;
15278   return jresult;
15279 }
15280
15281
15282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_Assign(void * jarg1, void * jarg2) {
15283   void * jresult ;
15284   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15285   Dali::Property::Value *arg2 = 0 ;
15286   Dali::Property::Value *result = 0 ;
15287
15288   arg1 = (Dali::Property::Value *)jarg1;
15289   arg2 = (Dali::Property::Value *)jarg2;
15290   if (!arg2) {
15291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15292     return 0;
15293   }
15294   {
15295     try {
15296       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15297     } catch (std::out_of_range& e) {
15298       {
15299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (std::exception& e) {
15302       {
15303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (...) {
15306       {
15307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15308       };
15309     }
15310   }
15311   jresult = (void *)result;
15312   return jresult;
15313 }
15314
15315
15316 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Value(void * jarg1) {
15317   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15318
15319   arg1 = (Dali::Property::Value *)jarg1;
15320   {
15321     try {
15322       delete arg1;
15323     } catch (std::out_of_range& e) {
15324       {
15325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15326       };
15327     } catch (std::exception& e) {
15328       {
15329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15330       };
15331     } catch (...) {
15332       {
15333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15334       };
15335     }
15336   }
15337 }
15338
15339
15340 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Value_GetType(void * jarg1) {
15341   int jresult ;
15342   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15343   Dali::Property::Type result;
15344
15345   arg1 = (Dali::Property::Value *)jarg1;
15346   {
15347     try {
15348       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15349     } catch (std::out_of_range& e) {
15350       {
15351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15352       };
15353     } catch (std::exception& e) {
15354       {
15355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15356       };
15357     } catch (...) {
15358       {
15359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15360       };
15361     }
15362   }
15363   jresult = (int)result;
15364   return jresult;
15365 }
15366
15367
15368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15369   unsigned int jresult ;
15370   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15371   bool *arg2 = 0 ;
15372   bool result;
15373
15374   arg1 = (Dali::Property::Value *)jarg1;
15375   arg2 = (bool *)jarg2;
15376   {
15377     try {
15378       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15379     } catch (std::out_of_range& e) {
15380       {
15381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (std::exception& e) {
15384       {
15385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393   jresult = result;
15394   return jresult;
15395 }
15396
15397
15398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15399   unsigned int jresult ;
15400   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15401   float *arg2 = 0 ;
15402   bool result;
15403
15404   arg1 = (Dali::Property::Value *)jarg1;
15405   arg2 = (float *)jarg2;
15406   {
15407     try {
15408       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15409     } catch (std::out_of_range& e) {
15410       {
15411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15412       };
15413     } catch (std::exception& e) {
15414       {
15415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15416       };
15417     } catch (...) {
15418       {
15419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15420       };
15421     }
15422   }
15423   jresult = result;
15424   return jresult;
15425 }
15426
15427
15428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15429   unsigned int jresult ;
15430   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15431   int *arg2 = 0 ;
15432   bool result;
15433
15434   arg1 = (Dali::Property::Value *)jarg1;
15435   arg2 = (int *)jarg2;
15436   {
15437     try {
15438       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15439     } catch (std::out_of_range& e) {
15440       {
15441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15442       };
15443     } catch (std::exception& e) {
15444       {
15445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15446       };
15447     } catch (...) {
15448       {
15449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15450       };
15451     }
15452   }
15453   jresult = result;
15454   return jresult;
15455 }
15456
15457
15458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15459   unsigned int jresult ;
15460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15461   Dali::Rect< int > *arg2 = 0 ;
15462   bool result;
15463
15464   arg1 = (Dali::Property::Value *)jarg1;
15465   arg2 = (Dali::Rect< int > *)jarg2;
15466   if (!arg2) {
15467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15468     return 0;
15469   }
15470   {
15471     try {
15472       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15473     } catch (std::out_of_range& e) {
15474       {
15475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15476       };
15477     } catch (std::exception& e) {
15478       {
15479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15480       };
15481     } catch (...) {
15482       {
15483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15484       };
15485     }
15486   }
15487   jresult = result;
15488   return jresult;
15489 }
15490
15491
15492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15493   unsigned int jresult ;
15494   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15495   Dali::Vector2 *arg2 = 0 ;
15496   bool result;
15497
15498   arg1 = (Dali::Property::Value *)jarg1;
15499   arg2 = (Dali::Vector2 *)jarg2;
15500   if (!arg2) {
15501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15502     return 0;
15503   }
15504   {
15505     try {
15506       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15507     } catch (std::out_of_range& e) {
15508       {
15509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15510       };
15511     } catch (std::exception& e) {
15512       {
15513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15514       };
15515     } catch (...) {
15516       {
15517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15518       };
15519     }
15520   }
15521   jresult = result;
15522   return jresult;
15523 }
15524
15525
15526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15527   unsigned int jresult ;
15528   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15529   Dali::Vector3 *arg2 = 0 ;
15530   bool result;
15531
15532   arg1 = (Dali::Property::Value *)jarg1;
15533   arg2 = (Dali::Vector3 *)jarg2;
15534   if (!arg2) {
15535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15536     return 0;
15537   }
15538   {
15539     try {
15540       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15541     } catch (std::out_of_range& e) {
15542       {
15543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15544       };
15545     } catch (std::exception& e) {
15546       {
15547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15548       };
15549     } catch (...) {
15550       {
15551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15552       };
15553     }
15554   }
15555   jresult = result;
15556   return jresult;
15557 }
15558
15559
15560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15561   unsigned int jresult ;
15562   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15563   Dali::Vector4 *arg2 = 0 ;
15564   bool result;
15565
15566   arg1 = (Dali::Property::Value *)jarg1;
15567   arg2 = (Dali::Vector4 *)jarg2;
15568   if (!arg2) {
15569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15570     return 0;
15571   }
15572   {
15573     try {
15574       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15575     } catch (std::out_of_range& e) {
15576       {
15577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15578       };
15579     } catch (std::exception& e) {
15580       {
15581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15582       };
15583     } catch (...) {
15584       {
15585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15586       };
15587     }
15588   }
15589   jresult = result;
15590   return jresult;
15591 }
15592
15593
15594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15595   unsigned int jresult ;
15596   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15597   Dali::Matrix3 *arg2 = 0 ;
15598   bool result;
15599
15600   arg1 = (Dali::Property::Value *)jarg1;
15601   arg2 = (Dali::Matrix3 *)jarg2;
15602   if (!arg2) {
15603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15604     return 0;
15605   }
15606   {
15607     try {
15608       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15609     } catch (std::out_of_range& e) {
15610       {
15611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15612       };
15613     } catch (std::exception& e) {
15614       {
15615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15616       };
15617     } catch (...) {
15618       {
15619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15620       };
15621     }
15622   }
15623   jresult = result;
15624   return jresult;
15625 }
15626
15627
15628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15629   unsigned int jresult ;
15630   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15631   Dali::Matrix *arg2 = 0 ;
15632   bool result;
15633
15634   arg1 = (Dali::Property::Value *)jarg1;
15635   arg2 = (Dali::Matrix *)jarg2;
15636   if (!arg2) {
15637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15638     return 0;
15639   }
15640   {
15641     try {
15642       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15643     } catch (std::out_of_range& e) {
15644       {
15645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (std::exception& e) {
15648       {
15649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15650       };
15651     } catch (...) {
15652       {
15653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15654       };
15655     }
15656   }
15657   jresult = result;
15658   return jresult;
15659 }
15660
15661
15662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15663   unsigned int jresult ;
15664   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15665   Dali::AngleAxis *arg2 = 0 ;
15666   bool result;
15667
15668   arg1 = (Dali::Property::Value *)jarg1;
15669   arg2 = (Dali::AngleAxis *)jarg2;
15670   if (!arg2) {
15671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15672     return 0;
15673   }
15674   {
15675     try {
15676       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (...) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15688       };
15689     }
15690   }
15691   jresult = result;
15692   return jresult;
15693 }
15694
15695
15696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15697   unsigned int jresult ;
15698   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15699   Dali::Quaternion *arg2 = 0 ;
15700   bool result;
15701
15702   arg1 = (Dali::Property::Value *)jarg1;
15703   arg2 = (Dali::Quaternion *)jarg2;
15704   if (!arg2) {
15705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15706     return 0;
15707   }
15708   {
15709     try {
15710       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15711     } catch (std::out_of_range& e) {
15712       {
15713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15714       };
15715     } catch (std::exception& e) {
15716       {
15717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (...) {
15720       {
15721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15722       };
15723     }
15724   }
15725   jresult = result;
15726   return jresult;
15727 }
15728
15729
15730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15731   unsigned int jresult ;
15732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15733   std::string *arg2 = 0 ;
15734   bool result;
15735
15736   arg1 = (Dali::Property::Value *)jarg1;
15737
15738   //typemap in
15739   std::string temp;
15740   arg2 = &temp;
15741
15742   {
15743     try {
15744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15745     } catch (std::out_of_range& e) {
15746       {
15747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15748       };
15749     } catch (std::exception& e) {
15750       {
15751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15756       };
15757     }
15758   }
15759   jresult = result;
15760
15761   //Typemap argout in c++ file.
15762   //This will convert c++ string to c# string
15763   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15764
15765   return jresult;
15766 }
15767
15768
15769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15770   unsigned int jresult ;
15771   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15772   Dali::Property::Array *arg2 = 0 ;
15773   bool result;
15774
15775   arg1 = (Dali::Property::Value *)jarg1;
15776   arg2 = (Dali::Property::Array *)jarg2;
15777   if (!arg2) {
15778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15779     return 0;
15780   }
15781   {
15782     try {
15783       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15784     } catch (std::out_of_range& e) {
15785       {
15786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15787       };
15788     } catch (std::exception& e) {
15789       {
15790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15791       };
15792     } catch (...) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15795       };
15796     }
15797   }
15798   jresult = result;
15799   return jresult;
15800 }
15801
15802
15803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15804   unsigned int jresult ;
15805   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15806   Dali::Property::Map *arg2 = 0 ;
15807   bool result;
15808
15809   arg1 = (Dali::Property::Value *)jarg1;
15810   arg2 = (Dali::Property::Map *)jarg2;
15811   if (!arg2) {
15812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15813     return 0;
15814   }
15815   {
15816     try {
15817       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15818     } catch (std::out_of_range& e) {
15819       {
15820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15821       };
15822     } catch (std::exception& e) {
15823       {
15824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15825       };
15826     } catch (...) {
15827       {
15828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15829       };
15830     }
15831   }
15832   jresult = result;
15833   return jresult;
15834 }
15835
15836
15837 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_GetArray(void * jarg1) {
15838   void * jresult ;
15839   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15840   Dali::Property::Array *result = 0 ;
15841
15842   arg1 = (Dali::Property::Value *)jarg1;
15843   {
15844     try {
15845       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15846     } catch (std::out_of_range& e) {
15847       {
15848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15849       };
15850     } catch (std::exception& e) {
15851       {
15852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (...) {
15855       {
15856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15857       };
15858     }
15859   }
15860   jresult = (void *)result;
15861   return jresult;
15862 }
15863
15864
15865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_GetMap(void * jarg1) {
15866   void * jresult ;
15867   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15868   Dali::Property::Map *result = 0 ;
15869
15870   arg1 = (Dali::Property::Value *)jarg1;
15871   {
15872     try {
15873       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15874     } catch (std::out_of_range& e) {
15875       {
15876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15877       };
15878     } catch (std::exception& e) {
15879       {
15880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15881       };
15882     } catch (...) {
15883       {
15884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15885       };
15886     }
15887   }
15888   jresult = (void *)result;
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_GetName(int jarg1) {
15894   char * jresult ;
15895   Dali::Property::Type arg1 ;
15896   char *result = 0 ;
15897
15898   arg1 = (Dali::Property::Type)jarg1;
15899   {
15900     try {
15901       result = (char *)Dali::PropertyTypes::GetName(arg1);
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (...) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15913       };
15914     }
15915   }
15916   jresult = SWIG_csharp_string_callback((const char *)result);
15917   return jresult;
15918 }
15919
15920
15921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15922   unsigned int jresult ;
15923   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15924   std::string *arg2 = 0 ;
15925   Dali::Property::Map *arg3 = 0 ;
15926   bool result;
15927
15928   arg1 = (Dali::BaseObject *)jarg1;
15929   if (!jarg2) {
15930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15931     return 0;
15932   }
15933   std::string arg2_str(jarg2);
15934   arg2 = &arg2_str;
15935   arg3 = (Dali::Property::Map *)jarg3;
15936   if (!arg3) {
15937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15938     return 0;
15939   }
15940   {
15941     try {
15942       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15943     } catch (std::out_of_range& e) {
15944       {
15945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15946       };
15947     } catch (std::exception& e) {
15948       {
15949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (...) {
15952       {
15953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15954       };
15955     }
15956   }
15957   jresult = result;
15958
15959   //argout typemap for const std::string&
15960
15961   return jresult;
15962 }
15963
15964
15965 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_BaseObject_GetTypeName(void * jarg1) {
15966   char * jresult ;
15967   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15968   std::string *result = 0 ;
15969
15970   arg1 = (Dali::BaseObject *)jarg1;
15971   {
15972     try {
15973       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15974     } catch (std::out_of_range& e) {
15975       {
15976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15977       };
15978     } catch (std::exception& e) {
15979       {
15980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15981       };
15982     } catch (...) {
15983       {
15984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15985       };
15986     }
15987   }
15988   jresult = SWIG_csharp_string_callback(result->c_str());
15989   return jresult;
15990 }
15991
15992
15993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15994   unsigned int jresult ;
15995   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15996   Dali::TypeInfo *arg2 = 0 ;
15997   bool result;
15998
15999   arg1 = (Dali::BaseObject *)jarg1;
16000   arg2 = (Dali::TypeInfo *)jarg2;
16001   if (!arg2) {
16002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16003     return 0;
16004   }
16005   {
16006     try {
16007       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16008     } catch (std::out_of_range& e) {
16009       {
16010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16011       };
16012     } catch (std::exception& e) {
16013       {
16014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16015       };
16016     } catch (...) {
16017       {
16018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16019       };
16020     }
16021   }
16022   jresult = result;
16023   return jresult;
16024 }
16025
16026
16027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16028   unsigned int jresult ;
16029   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16030   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16031   std::string *arg3 = 0 ;
16032   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16033   bool result;
16034
16035   arg1 = (Dali::BaseObject *)jarg1;
16036   arg2 = (ConnectionTrackerInterface *)jarg2;
16037   if (!jarg3) {
16038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16039     return 0;
16040   }
16041   std::string arg3_str(jarg3);
16042   arg3 = &arg3_str;
16043   arg4 = (FunctorDelegate *)jarg4;
16044   {
16045     try {
16046       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16047     } catch (std::out_of_range& e) {
16048       {
16049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16050       };
16051     } catch (std::exception& e) {
16052       {
16053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16054       };
16055     } catch (...) {
16056       {
16057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16058       };
16059     }
16060   }
16061   jresult = result;
16062
16063   //argout typemap for const std::string&
16064
16065   return jresult;
16066 }
16067
16068
16069 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GetImplementation(void * jarg1) {
16070   void * jresult ;
16071   Dali::BaseHandle *arg1 = 0 ;
16072   Dali::BaseObject *result = 0 ;
16073
16074   arg1 = (Dali::BaseHandle *)jarg1;
16075   if (!arg1) {
16076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16077     return 0;
16078   }
16079   {
16080     try {
16081       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16082     } catch (std::out_of_range& e) {
16083       {
16084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16085       };
16086     } catch (std::exception& e) {
16087       {
16088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16089       };
16090     } catch (...) {
16091       {
16092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16093       };
16094     }
16095   }
16096   jresult = (void *)result;
16097   return jresult;
16098 }
16099
16100
16101 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_0(void * jarg1) {
16102   void * jresult ;
16103   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16104   Dali::BaseHandle *result = 0 ;
16105
16106   arg1 = (Dali::BaseObject *)jarg1;
16107   {
16108     try {
16109       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16110     } catch (std::out_of_range& e) {
16111       {
16112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16113       };
16114     } catch (std::exception& e) {
16115       {
16116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16117       };
16118     } catch (...) {
16119       {
16120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16121       };
16122     }
16123   }
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_1() {
16130   void * jresult ;
16131   Dali::BaseHandle *result = 0 ;
16132
16133   {
16134     try {
16135       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16136     } catch (std::out_of_range& e) {
16137       {
16138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16139       };
16140     } catch (std::exception& e) {
16141       {
16142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (...) {
16145       {
16146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16147       };
16148     }
16149   }
16150   jresult = (void *)result;
16151   return jresult;
16152 }
16153
16154
16155 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BaseHandle(void * jarg1) {
16156   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16157
16158   arg1 = (Dali::BaseHandle *)jarg1;
16159   {
16160     try {
16161       delete arg1;
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16169       };
16170     } catch (...) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16173       };
16174     }
16175   }
16176 }
16177
16178
16179 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_2(void * jarg1) {
16180   void * jresult ;
16181   Dali::BaseHandle *arg1 = 0 ;
16182   Dali::BaseHandle *result = 0 ;
16183
16184   arg1 = (Dali::BaseHandle *)jarg1;
16185   if (!arg1) {
16186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16187     return 0;
16188   }
16189   {
16190     try {
16191       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16192     } catch (std::out_of_range& e) {
16193       {
16194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16195       };
16196     } catch (std::exception& e) {
16197       {
16198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16199       };
16200     } catch (...) {
16201       {
16202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16203       };
16204     }
16205   }
16206   jresult = (void *)result;
16207   return jresult;
16208 }
16209
16210
16211 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_Assign(void * jarg1, void * jarg2) {
16212   void * jresult ;
16213   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16214   Dali::BaseHandle *arg2 = 0 ;
16215   Dali::BaseHandle *result = 0 ;
16216
16217   arg1 = (Dali::BaseHandle *)jarg1;
16218   arg2 = (Dali::BaseHandle *)jarg2;
16219   if (!arg2) {
16220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16221     return 0;
16222   }
16223   {
16224     try {
16225       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16226     } catch (std::out_of_range& e) {
16227       {
16228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16229       };
16230     } catch (std::exception& e) {
16231       {
16232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16233       };
16234     } catch (...) {
16235       {
16236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16237       };
16238     }
16239   }
16240   jresult = (void *)result;
16241   return jresult;
16242 }
16243
16244
16245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16246   unsigned int jresult ;
16247   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16248   std::string *arg2 = 0 ;
16249   Dali::Property::Map *arg3 = 0 ;
16250   bool result;
16251
16252   arg1 = (Dali::BaseHandle *)jarg1;
16253   if (!jarg2) {
16254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16255     return 0;
16256   }
16257   std::string arg2_str(jarg2);
16258   arg2 = &arg2_str;
16259   arg3 = (Dali::Property::Map *)jarg3;
16260   if (!arg3) {
16261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16262     return 0;
16263   }
16264   {
16265     try {
16266       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16267     } catch (std::out_of_range& e) {
16268       {
16269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16270       };
16271     } catch (std::exception& e) {
16272       {
16273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16274       };
16275     } catch (...) {
16276       {
16277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16278       };
16279     }
16280   }
16281   jresult = result;
16282
16283   //argout typemap for const std::string&
16284
16285   return jresult;
16286 }
16287
16288
16289 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_BaseHandle_GetTypeName(void * jarg1) {
16290   char * jresult ;
16291   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16292   std::string *result = 0 ;
16293
16294   arg1 = (Dali::BaseHandle *)jarg1;
16295   {
16296     try {
16297       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16298     } catch (std::out_of_range& e) {
16299       {
16300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16301       };
16302     } catch (std::exception& e) {
16303       {
16304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16305       };
16306     } catch (...) {
16307       {
16308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16309       };
16310     }
16311   }
16312   jresult = SWIG_csharp_string_callback(result->c_str());
16313   return jresult;
16314 }
16315
16316
16317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16318   unsigned int jresult ;
16319   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16320   Dali::TypeInfo *arg2 = 0 ;
16321   bool result;
16322
16323   arg1 = (Dali::BaseHandle *)jarg1;
16324   arg2 = (Dali::TypeInfo *)jarg2;
16325   if (!arg2) {
16326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16327     return 0;
16328   }
16329   {
16330     try {
16331       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16332     } catch (std::out_of_range& e) {
16333       {
16334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16335       };
16336     } catch (std::exception& e) {
16337       {
16338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16339       };
16340     } catch (...) {
16341       {
16342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16343       };
16344     }
16345   }
16346   jresult = result;
16347   return jresult;
16348 }
16349
16350
16351 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16352   void * jresult ;
16353   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16354   Dali::BaseObject *result = 0 ;
16355
16356   arg1 = (Dali::BaseHandle *)jarg1;
16357   {
16358     try {
16359       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16360     } catch (std::out_of_range& e) {
16361       {
16362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16363       };
16364     } catch (std::exception& e) {
16365       {
16366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (...) {
16369       {
16370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16371       };
16372     }
16373   }
16374   jresult = (void *)result;
16375   return jresult;
16376 }
16377
16378
16379 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BaseHandle_Reset(void * jarg1) {
16380   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16381
16382   arg1 = (Dali::BaseHandle *)jarg1;
16383   {
16384     try {
16385       (arg1)->Reset();
16386     } catch (std::out_of_range& e) {
16387       {
16388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16389       };
16390     } catch (std::exception& e) {
16391       {
16392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16393       };
16394     } catch (...) {
16395       {
16396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16397       };
16398     }
16399   }
16400 }
16401
16402
16403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16404   unsigned int jresult ;
16405   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16406   Dali::BaseHandle *arg2 = 0 ;
16407   bool result;
16408
16409   arg1 = (Dali::BaseHandle *)jarg1;
16410   arg2 = (Dali::BaseHandle *)jarg2;
16411   if (!arg2) {
16412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16413     return 0;
16414   }
16415   {
16416     try {
16417       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16418     } catch (std::out_of_range& e) {
16419       {
16420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16421       };
16422     } catch (std::exception& e) {
16423       {
16424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16425       };
16426     } catch (...) {
16427       {
16428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16429       };
16430     }
16431   }
16432   jresult = result;
16433   return jresult;
16434 }
16435
16436
16437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16438   unsigned int jresult ;
16439   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16440   Dali::BaseHandle *arg2 = 0 ;
16441   bool result;
16442
16443   arg1 = (Dali::BaseHandle *)jarg1;
16444   arg2 = (Dali::BaseHandle *)jarg2;
16445   if (!arg2) {
16446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16447     return 0;
16448   }
16449   {
16450     try {
16451       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16452     } catch (std::out_of_range& e) {
16453       {
16454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16455       };
16456     } catch (std::exception& e) {
16457       {
16458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16459       };
16460     } catch (...) {
16461       {
16462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16463       };
16464     }
16465   }
16466   jresult = result;
16467   return jresult;
16468 }
16469
16470
16471 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_GetObjectPtr(void * jarg1) {
16472   void * jresult ;
16473   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16474   Dali::RefObject *result = 0 ;
16475
16476   arg1 = (Dali::BaseHandle *)jarg1;
16477   {
16478     try {
16479       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16480     } catch (std::out_of_range& e) {
16481       {
16482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16483       };
16484     } catch (std::exception& e) {
16485       {
16486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16487       };
16488     } catch (...) {
16489       {
16490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16491       };
16492     }
16493   }
16494   jresult = (void *)result;
16495   return jresult;
16496 }
16497
16498
16499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_HasBody(void * jarg1) {
16500   unsigned int jresult ;
16501   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16502   bool result;
16503
16504   arg1 = (Dali::BaseHandle *)jarg1;
16505   {
16506     try {
16507       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16515       };
16516     } catch (...) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16519       };
16520     }
16521   }
16522   jresult = result;
16523   return jresult;
16524 }
16525
16526
16527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16528   unsigned int jresult ;
16529   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16530   Dali::BaseHandle *arg2 = 0 ;
16531   bool result;
16532
16533   arg1 = (Dali::BaseHandle *)jarg1;
16534   arg2 = (Dali::BaseHandle *)jarg2;
16535   if (!arg2) {
16536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16537     return 0;
16538   }
16539   {
16540     try {
16541       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16542     } catch (std::out_of_range& e) {
16543       {
16544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16545       };
16546     } catch (std::exception& e) {
16547       {
16548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (...) {
16551       {
16552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16553       };
16554     }
16555   }
16556   jresult = result;
16557   return jresult;
16558 }
16559
16560
16561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16562   unsigned int jresult ;
16563   Dali::BaseHandle *arg1 = 0 ;
16564   Dali::BaseHandle *arg2 = 0 ;
16565   bool result;
16566
16567   arg1 = (Dali::BaseHandle *)jarg1;
16568   if (!arg1) {
16569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16570     return 0;
16571   }
16572   arg2 = (Dali::BaseHandle *)jarg2;
16573   if (!arg2) {
16574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16575     return 0;
16576   }
16577   {
16578     try {
16579       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16580     } catch (std::out_of_range& e) {
16581       {
16582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (std::exception& e) {
16585       {
16586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594   jresult = result;
16595   return jresult;
16596 }
16597
16598
16599 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ConnectionTrackerInterface(void * jarg1) {
16600   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16601
16602   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16603   {
16604     try {
16605       delete arg1;
16606     } catch (std::out_of_range& e) {
16607       {
16608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16609       };
16610     } catch (std::exception& e) {
16611       {
16612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16613       };
16614     } catch (...) {
16615       {
16616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16617       };
16618     }
16619   }
16620 }
16621
16622
16623 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16624   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16625   SlotObserver *arg2 = (SlotObserver *) 0 ;
16626   CallbackBase *arg3 = (CallbackBase *) 0 ;
16627
16628   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16629   arg2 = (SlotObserver *)jarg2;
16630   arg3 = (CallbackBase *)jarg3;
16631   {
16632     try {
16633       (arg1)->SignalConnected(arg2,arg3);
16634     } catch (std::out_of_range& e) {
16635       {
16636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16637       };
16638     } catch (std::exception& e) {
16639       {
16640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16641       };
16642     } catch (...) {
16643       {
16644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16645       };
16646     }
16647   }
16648 }
16649
16650
16651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SignalObserver(void * jarg1) {
16652   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16653
16654   arg1 = (Dali::SignalObserver *)jarg1;
16655   {
16656     try {
16657       delete arg1;
16658     } catch (std::out_of_range& e) {
16659       {
16660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16661       };
16662     } catch (std::exception& e) {
16663       {
16664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16669       };
16670     }
16671   }
16672 }
16673
16674
16675 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16676   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16677   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16678   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16679
16680   arg1 = (Dali::SignalObserver *)jarg1;
16681   arg2 = (Dali::SlotObserver *)jarg2;
16682   arg3 = (Dali::CallbackBase *)jarg3;
16683   {
16684     try {
16685       (arg1)->SignalDisconnected(arg2,arg3);
16686     } catch (std::out_of_range& e) {
16687       {
16688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16689       };
16690     } catch (std::exception& e) {
16691       {
16692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16693       };
16694     } catch (...) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16697       };
16698     }
16699   }
16700 }
16701
16702
16703 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SlotObserver(void * jarg1) {
16704   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16705
16706   arg1 = (Dali::SlotObserver *)jarg1;
16707   {
16708     try {
16709       delete arg1;
16710     } catch (std::out_of_range& e) {
16711       {
16712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16713       };
16714     } catch (std::exception& e) {
16715       {
16716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16717       };
16718     } catch (...) {
16719       {
16720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16721       };
16722     }
16723   }
16724 }
16725
16726
16727 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16728   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16729   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16730
16731   arg1 = (Dali::SlotObserver *)jarg1;
16732   arg2 = (Dali::CallbackBase *)jarg2;
16733   {
16734     try {
16735       (arg1)->SlotDisconnected(arg2);
16736     } catch (std::out_of_range& e) {
16737       {
16738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16739       };
16740     } catch (std::exception& e) {
16741       {
16742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16743       };
16744     } catch (...) {
16745       {
16746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16747       };
16748     }
16749   }
16750 }
16751
16752
16753 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ConnectionTracker(void * jarg1) {
16754   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16755
16756   arg1 = (Dali::ConnectionTracker *)jarg1;
16757   {
16758     try {
16759       delete arg1;
16760     } catch (std::out_of_range& e) {
16761       {
16762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16763       };
16764     } catch (std::exception& e) {
16765       {
16766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16767       };
16768     } catch (...) {
16769       {
16770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16771       };
16772     }
16773   }
16774 }
16775
16776
16777 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_DisconnectAll(void * jarg1) {
16778   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16779
16780   arg1 = (Dali::ConnectionTracker *)jarg1;
16781   {
16782     try {
16783       (arg1)->DisconnectAll();
16784     } catch (std::out_of_range& e) {
16785       {
16786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16787       };
16788     } catch (std::exception& e) {
16789       {
16790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16791       };
16792     } catch (...) {
16793       {
16794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16795       };
16796     }
16797   }
16798 }
16799
16800
16801 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16802   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16803   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16804   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16805
16806   arg1 = (Dali::ConnectionTracker *)jarg1;
16807   arg2 = (Dali::SlotObserver *)jarg2;
16808   arg3 = (Dali::CallbackBase *)jarg3;
16809   {
16810     try {
16811       (arg1)->SignalConnected(arg2,arg3);
16812     } catch (std::out_of_range& e) {
16813       {
16814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16815       };
16816     } catch (std::exception& e) {
16817       {
16818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16823       };
16824     }
16825   }
16826 }
16827
16828
16829 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16830   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16831   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16832   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16833
16834   arg1 = (Dali::ConnectionTracker *)jarg1;
16835   arg2 = (Dali::SlotObserver *)jarg2;
16836   arg3 = (Dali::CallbackBase *)jarg3;
16837   {
16838     try {
16839       (arg1)->SignalDisconnected(arg2,arg3);
16840     } catch (std::out_of_range& e) {
16841       {
16842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16843       };
16844     } catch (std::exception& e) {
16845       {
16846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16847       };
16848     } catch (...) {
16849       {
16850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16851       };
16852     }
16853   }
16854 }
16855
16856
16857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ConnectionTracker_GetConnectionCount(void * jarg1) {
16858   unsigned long jresult ;
16859   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16860   std::size_t result;
16861
16862   arg1 = (Dali::ConnectionTracker *)jarg1;
16863   {
16864     try {
16865       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16866     } catch (std::out_of_range& e) {
16867       {
16868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (std::exception& e) {
16871       {
16872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880   jresult = (unsigned long)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectRegistry__SWIG_0() {
16886   void * jresult ;
16887   Dali::ObjectRegistry *result = 0 ;
16888
16889   {
16890     try {
16891       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16892     } catch (std::out_of_range& e) {
16893       {
16894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16895       };
16896     } catch (std::exception& e) {
16897       {
16898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (...) {
16901       {
16902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16903       };
16904     }
16905   }
16906   jresult = (void *)result;
16907   return jresult;
16908 }
16909
16910
16911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectRegistry(void * jarg1) {
16912   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16913
16914   arg1 = (Dali::ObjectRegistry *)jarg1;
16915   {
16916     try {
16917       delete arg1;
16918     } catch (std::out_of_range& e) {
16919       {
16920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16921       };
16922     } catch (std::exception& e) {
16923       {
16924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16925       };
16926     } catch (...) {
16927       {
16928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16929       };
16930     }
16931   }
16932 }
16933
16934
16935 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectRegistry__SWIG_1(void * jarg1) {
16936   void * jresult ;
16937   Dali::ObjectRegistry *arg1 = 0 ;
16938   Dali::ObjectRegistry *result = 0 ;
16939
16940   arg1 = (Dali::ObjectRegistry *)jarg1;
16941   if (!arg1) {
16942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16943     return 0;
16944   }
16945   {
16946     try {
16947       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16948     } catch (std::out_of_range& e) {
16949       {
16950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16951       };
16952     } catch (std::exception& e) {
16953       {
16954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16955       };
16956     } catch (...) {
16957       {
16958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16959       };
16960     }
16961   }
16962   jresult = (void *)result;
16963   return jresult;
16964 }
16965
16966
16967 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16968   void * jresult ;
16969   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16970   Dali::ObjectRegistry *arg2 = 0 ;
16971   Dali::ObjectRegistry *result = 0 ;
16972
16973   arg1 = (Dali::ObjectRegistry *)jarg1;
16974   arg2 = (Dali::ObjectRegistry *)jarg2;
16975   if (!arg2) {
16976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16977     return 0;
16978   }
16979   {
16980     try {
16981       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16982     } catch (std::out_of_range& e) {
16983       {
16984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16985       };
16986     } catch (std::exception& e) {
16987       {
16988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16989       };
16990     } catch (...) {
16991       {
16992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16993       };
16994     }
16995   }
16996   jresult = (void *)result;
16997   return jresult;
16998 }
16999
17000
17001 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17002   void * jresult ;
17003   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17004   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17005
17006   arg1 = (Dali::ObjectRegistry *)jarg1;
17007   {
17008     try {
17009       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024   jresult = (void *)result;
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17030   void * jresult ;
17031   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17032   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17033
17034   arg1 = (Dali::ObjectRegistry *)jarg1;
17035   {
17036     try {
17037       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17038     } catch (std::out_of_range& e) {
17039       {
17040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17041       };
17042     } catch (std::exception& e) {
17043       {
17044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17045       };
17046     } catch (...) {
17047       {
17048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17049       };
17050     }
17051   }
17052   jresult = (void *)result;
17053   return jresult;
17054 }
17055
17056
17057 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyCondition__SWIG_0() {
17058   void * jresult ;
17059   Dali::PropertyCondition *result = 0 ;
17060
17061   {
17062     try {
17063       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17064     } catch (std::out_of_range& e) {
17065       {
17066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17067       };
17068     } catch (std::exception& e) {
17069       {
17070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17071       };
17072     } catch (...) {
17073       {
17074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17075       };
17076     }
17077   }
17078   jresult = (void *)result;
17079   return jresult;
17080 }
17081
17082
17083 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyCondition(void * jarg1) {
17084   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17085
17086   arg1 = (Dali::PropertyCondition *)jarg1;
17087   {
17088     try {
17089       delete arg1;
17090     } catch (std::out_of_range& e) {
17091       {
17092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17093       };
17094     } catch (std::exception& e) {
17095       {
17096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17097       };
17098     } catch (...) {
17099       {
17100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17101       };
17102     }
17103   }
17104 }
17105
17106
17107 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyCondition__SWIG_1(void * jarg1) {
17108   void * jresult ;
17109   Dali::PropertyCondition *arg1 = 0 ;
17110   Dali::PropertyCondition *result = 0 ;
17111
17112   arg1 = (Dali::PropertyCondition *)jarg1;
17113   if (!arg1) {
17114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17115     return 0;
17116   }
17117   {
17118     try {
17119       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17120     } catch (std::out_of_range& e) {
17121       {
17122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17123       };
17124     } catch (std::exception& e) {
17125       {
17126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17127       };
17128     } catch (...) {
17129       {
17130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17131       };
17132     }
17133   }
17134   jresult = (void *)result;
17135   return jresult;
17136 }
17137
17138
17139 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17140   void * jresult ;
17141   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17142   Dali::PropertyCondition *arg2 = 0 ;
17143   Dali::PropertyCondition *result = 0 ;
17144
17145   arg1 = (Dali::PropertyCondition *)jarg1;
17146   arg2 = (Dali::PropertyCondition *)jarg2;
17147   if (!arg2) {
17148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17149     return 0;
17150   }
17151   {
17152     try {
17153       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17154     } catch (std::out_of_range& e) {
17155       {
17156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17157       };
17158     } catch (std::exception& e) {
17159       {
17160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (...) {
17163       {
17164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17165       };
17166     }
17167   }
17168   jresult = (void *)result;
17169   return jresult;
17170 }
17171
17172
17173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyCondition_GetArgumentCount(void * jarg1) {
17174   unsigned long jresult ;
17175   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17176   std::size_t result;
17177
17178   arg1 = (Dali::PropertyCondition *)jarg1;
17179   {
17180     try {
17181       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17182     } catch (std::out_of_range& e) {
17183       {
17184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (std::exception& e) {
17187       {
17188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (...) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17193       };
17194     }
17195   }
17196   jresult = (unsigned long)result;
17197   return jresult;
17198 }
17199
17200
17201 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17202   float jresult ;
17203   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17204   std::size_t arg2 ;
17205   float result;
17206
17207   arg1 = (Dali::PropertyCondition *)jarg1;
17208   arg2 = (std::size_t)jarg2;
17209   {
17210     try {
17211       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17212     } catch (std::out_of_range& e) {
17213       {
17214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17215       };
17216     } catch (std::exception& e) {
17217       {
17218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17219       };
17220     } catch (...) {
17221       {
17222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17223       };
17224     }
17225   }
17226   jresult = result;
17227   return jresult;
17228 }
17229
17230
17231 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LessThanCondition(float jarg1) {
17232   void * jresult ;
17233   float arg1 ;
17234   Dali::PropertyCondition result;
17235
17236   arg1 = (float)jarg1;
17237   {
17238     try {
17239       result = Dali::LessThanCondition(arg1);
17240     } catch (std::out_of_range& e) {
17241       {
17242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17243       };
17244     } catch (std::exception& e) {
17245       {
17246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17247       };
17248     } catch (...) {
17249       {
17250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17251       };
17252     }
17253   }
17254   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17255   return jresult;
17256 }
17257
17258
17259 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GreaterThanCondition(float jarg1) {
17260   void * jresult ;
17261   float arg1 ;
17262   Dali::PropertyCondition result;
17263
17264   arg1 = (float)jarg1;
17265   {
17266     try {
17267       result = Dali::GreaterThanCondition(arg1);
17268     } catch (std::out_of_range& e) {
17269       {
17270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (std::exception& e) {
17273       {
17274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_InsideCondition(float jarg1, float jarg2) {
17288   void * jresult ;
17289   float arg1 ;
17290   float arg2 ;
17291   Dali::PropertyCondition result;
17292
17293   arg1 = (float)jarg1;
17294   arg2 = (float)jarg2;
17295   {
17296     try {
17297       result = Dali::InsideCondition(arg1,arg2);
17298     } catch (std::out_of_range& e) {
17299       {
17300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17301       };
17302     } catch (std::exception& e) {
17303       {
17304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (...) {
17307       {
17308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17309       };
17310     }
17311   }
17312   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17313   return jresult;
17314 }
17315
17316
17317 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_OutsideCondition(float jarg1, float jarg2) {
17318   void * jresult ;
17319   float arg1 ;
17320   float arg2 ;
17321   Dali::PropertyCondition result;
17322
17323   arg1 = (float)jarg1;
17324   arg2 = (float)jarg2;
17325   {
17326     try {
17327       result = Dali::OutsideCondition(arg1,arg2);
17328     } catch (std::out_of_range& e) {
17329       {
17330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17331       };
17332     } catch (std::exception& e) {
17333       {
17334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17335       };
17336     } catch (...) {
17337       {
17338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17339       };
17340     }
17341   }
17342   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17343   return jresult;
17344 }
17345
17346
17347 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StepCondition__SWIG_0(float jarg1, float jarg2) {
17348   void * jresult ;
17349   float arg1 ;
17350   float arg2 ;
17351   Dali::PropertyCondition result;
17352
17353   arg1 = (float)jarg1;
17354   arg2 = (float)jarg2;
17355   {
17356     try {
17357       result = Dali::StepCondition(arg1,arg2);
17358     } catch (std::out_of_range& e) {
17359       {
17360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17361       };
17362     } catch (std::exception& e) {
17363       {
17364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17365       };
17366     } catch (...) {
17367       {
17368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17369       };
17370     }
17371   }
17372   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17373   return jresult;
17374 }
17375
17376
17377 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StepCondition__SWIG_1(float jarg1) {
17378   void * jresult ;
17379   float arg1 ;
17380   Dali::PropertyCondition result;
17381
17382   arg1 = (float)jarg1;
17383   {
17384     try {
17385       result = Dali::StepCondition(arg1);
17386     } catch (std::out_of_range& e) {
17387       {
17388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17389       };
17390     } catch (std::exception& e) {
17391       {
17392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17393       };
17394     } catch (...) {
17395       {
17396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17397       };
17398     }
17399   }
17400   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17401   return jresult;
17402 }
17403
17404
17405 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VariableStepCondition(void * jarg1) {
17406   void * jresult ;
17407   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17408   Dali::PropertyCondition result;
17409
17410   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17411   if (!arg1) {
17412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17413     return 0;
17414   }
17415   {
17416     try {
17417       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17418     } catch (std::out_of_range& e) {
17419       {
17420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17421       };
17422     } catch (std::exception& e) {
17423       {
17424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (...) {
17427       {
17428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17429       };
17430     }
17431   }
17432   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17433   return jresult;
17434 }
17435
17436
17437 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotification__SWIG_0() {
17438   void * jresult ;
17439   Dali::PropertyNotification *result = 0 ;
17440
17441   {
17442     try {
17443       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17444     } catch (std::out_of_range& e) {
17445       {
17446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17447       };
17448     } catch (std::exception& e) {
17449       {
17450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17451       };
17452     } catch (...) {
17453       {
17454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17455       };
17456     }
17457   }
17458   jresult = (void *)result;
17459   return jresult;
17460 }
17461
17462
17463 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_DownCast(void * jarg1) {
17464   void * jresult ;
17465   Dali::BaseHandle arg1 ;
17466   Dali::BaseHandle *argp1 ;
17467   Dali::PropertyNotification result;
17468
17469   argp1 = (Dali::BaseHandle *)jarg1;
17470   if (!argp1) {
17471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17472     return 0;
17473   }
17474   arg1 = *argp1;
17475   {
17476     try {
17477       result = Dali::PropertyNotification::DownCast(arg1);
17478     } catch (std::out_of_range& e) {
17479       {
17480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17481       };
17482     } catch (std::exception& e) {
17483       {
17484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17485       };
17486     } catch (...) {
17487       {
17488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17489       };
17490     }
17491   }
17492   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17493   return jresult;
17494 }
17495
17496
17497 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyNotification(void * jarg1) {
17498   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17499
17500   arg1 = (Dali::PropertyNotification *)jarg1;
17501   {
17502     try {
17503       delete arg1;
17504     } catch (std::out_of_range& e) {
17505       {
17506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17507       };
17508     } catch (std::exception& e) {
17509       {
17510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17511       };
17512     } catch (...) {
17513       {
17514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17515       };
17516     }
17517   }
17518 }
17519
17520
17521 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotification__SWIG_1(void * jarg1) {
17522   void * jresult ;
17523   Dali::PropertyNotification *arg1 = 0 ;
17524   Dali::PropertyNotification *result = 0 ;
17525
17526   arg1 = (Dali::PropertyNotification *)jarg1;
17527   if (!arg1) {
17528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17529     return 0;
17530   }
17531   {
17532     try {
17533       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17534     } catch (std::out_of_range& e) {
17535       {
17536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17537       };
17538     } catch (std::exception& e) {
17539       {
17540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17541       };
17542     } catch (...) {
17543       {
17544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17545       };
17546     }
17547   }
17548   jresult = (void *)result;
17549   return jresult;
17550 }
17551
17552
17553 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17554   void * jresult ;
17555   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17556   Dali::PropertyNotification *arg2 = 0 ;
17557   Dali::PropertyNotification *result = 0 ;
17558
17559   arg1 = (Dali::PropertyNotification *)jarg1;
17560   arg2 = (Dali::PropertyNotification *)jarg2;
17561   if (!arg2) {
17562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17563     return 0;
17564   }
17565   {
17566     try {
17567       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17568     } catch (std::out_of_range& e) {
17569       {
17570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17571       };
17572     } catch (std::exception& e) {
17573       {
17574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17575       };
17576     } catch (...) {
17577       {
17578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17579       };
17580     }
17581   }
17582   jresult = (void *)result;
17583   return jresult;
17584 }
17585
17586
17587 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17588   void * jresult ;
17589   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17590   Dali::PropertyCondition result;
17591
17592   arg1 = (Dali::PropertyNotification *)jarg1;
17593   {
17594     try {
17595       result = (arg1)->GetCondition();
17596     } catch (std::out_of_range& e) {
17597       {
17598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17599       };
17600     } catch (std::exception& e) {
17601       {
17602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17603       };
17604     } catch (...) {
17605       {
17606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17607       };
17608     }
17609   }
17610   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17611   return jresult;
17612 }
17613
17614
17615 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_GetTarget(void * jarg1) {
17616   void * jresult ;
17617   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17618   Dali::Handle result;
17619
17620   arg1 = (Dali::PropertyNotification *)jarg1;
17621   {
17622     try {
17623       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17624     } catch (std::out_of_range& e) {
17625       {
17626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (std::exception& e) {
17629       {
17630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (...) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17635       };
17636     }
17637   }
17638   jresult = new Dali::Handle((const Dali::Handle &)result);
17639   return jresult;
17640 }
17641
17642
17643 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetTargetProperty(void * jarg1) {
17644   int jresult ;
17645   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17646   Dali::Property::Index result;
17647
17648   arg1 = (Dali::PropertyNotification *)jarg1;
17649   {
17650     try {
17651       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17652     } catch (std::out_of_range& e) {
17653       {
17654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (std::exception& e) {
17657       {
17658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666   jresult = result;
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17672   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17673   Dali::PropertyNotification::NotifyMode arg2 ;
17674
17675   arg1 = (Dali::PropertyNotification *)jarg1;
17676   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17677   {
17678     try {
17679       (arg1)->SetNotifyMode(arg2);
17680     } catch (std::out_of_range& e) {
17681       {
17682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17683       };
17684     } catch (std::exception& e) {
17685       {
17686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17687       };
17688     } catch (...) {
17689       {
17690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17691       };
17692     }
17693   }
17694 }
17695
17696
17697 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetNotifyMode(void * jarg1) {
17698   int jresult ;
17699   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17700   Dali::PropertyNotification::NotifyMode result;
17701
17702   arg1 = (Dali::PropertyNotification *)jarg1;
17703   {
17704     try {
17705       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (...) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17717       };
17718     }
17719   }
17720   jresult = (int)result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetNotifyResult(void * jarg1) {
17726   unsigned int jresult ;
17727   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17728   bool result;
17729
17730   arg1 = (Dali::PropertyNotification *)jarg1;
17731   {
17732     try {
17733       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17734     } catch (std::out_of_range& e) {
17735       {
17736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17737       };
17738     } catch (std::exception& e) {
17739       {
17740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17741       };
17742     } catch (...) {
17743       {
17744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17745       };
17746     }
17747   }
17748   jresult = result;
17749   return jresult;
17750 }
17751
17752
17753 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_NotifySignal(void * jarg1) {
17754   void * jresult ;
17755   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17756   Dali::PropertyNotifySignalType *result = 0 ;
17757
17758   arg1 = (Dali::PropertyNotification *)jarg1;
17759   {
17760     try {
17761       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17762     } catch (std::out_of_range& e) {
17763       {
17764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17765       };
17766     } catch (std::exception& e) {
17767       {
17768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17769       };
17770     } catch (...) {
17771       {
17772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17773       };
17774     }
17775   }
17776   jresult = (void *)result;
17777   return jresult;
17778 }
17779
17780
17781 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Handle__SWIG_0() {
17782   void * jresult ;
17783   Dali::Handle *result = 0 ;
17784
17785   {
17786     try {
17787       result = (Dali::Handle *)new Dali::Handle();
17788     } catch (std::out_of_range& e) {
17789       {
17790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (std::exception& e) {
17793       {
17794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802   jresult = (void *)result;
17803   return jresult;
17804 }
17805
17806
17807 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_New() {
17808   void * jresult ;
17809   Dali::Handle result;
17810
17811   {
17812     try {
17813       result = Dali::Handle::New();
17814     } catch (std::out_of_range& e) {
17815       {
17816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17817       };
17818     } catch (std::exception& e) {
17819       {
17820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (...) {
17823       {
17824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17825       };
17826     }
17827   }
17828   jresult = new Dali::Handle((const Dali::Handle &)result);
17829   return jresult;
17830 }
17831
17832
17833 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Handle(void * jarg1) {
17834   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17835
17836   arg1 = (Dali::Handle *)jarg1;
17837   {
17838     try {
17839       delete arg1;
17840     } catch (std::out_of_range& e) {
17841       {
17842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17843       };
17844     } catch (std::exception& e) {
17845       {
17846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17847       };
17848     } catch (...) {
17849       {
17850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17851       };
17852     }
17853   }
17854 }
17855
17856
17857 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Handle__SWIG_1(void * jarg1) {
17858   void * jresult ;
17859   Dali::Handle *arg1 = 0 ;
17860   Dali::Handle *result = 0 ;
17861
17862   arg1 = (Dali::Handle *)jarg1;
17863   if (!arg1) {
17864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17865     return 0;
17866   }
17867   {
17868     try {
17869       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17870     } catch (std::out_of_range& e) {
17871       {
17872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17873       };
17874     } catch (std::exception& e) {
17875       {
17876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17877       };
17878     } catch (...) {
17879       {
17880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17881       };
17882     }
17883   }
17884   jresult = (void *)result;
17885   return jresult;
17886 }
17887
17888
17889 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_Assign(void * jarg1, void * jarg2) {
17890   void * jresult ;
17891   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17892   Dali::Handle *arg2 = 0 ;
17893   Dali::Handle *result = 0 ;
17894
17895   arg1 = (Dali::Handle *)jarg1;
17896   arg2 = (Dali::Handle *)jarg2;
17897   if (!arg2) {
17898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17899     return 0;
17900   }
17901   {
17902     try {
17903       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17904     } catch (std::out_of_range& e) {
17905       {
17906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (std::exception& e) {
17909       {
17910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17911       };
17912     } catch (...) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17915       };
17916     }
17917   }
17918   jresult = (void *)result;
17919   return jresult;
17920 }
17921
17922
17923 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_DownCast(void * jarg1) {
17924   void * jresult ;
17925   Dali::BaseHandle arg1 ;
17926   Dali::BaseHandle *argp1 ;
17927   Dali::Handle result;
17928
17929   argp1 = (Dali::BaseHandle *)jarg1;
17930   if (!argp1) {
17931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17932     return 0;
17933   }
17934   arg1 = *argp1;
17935   {
17936     try {
17937       result = Dali::Handle::DownCast(arg1);
17938     } catch (std::out_of_range& e) {
17939       {
17940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17941       };
17942     } catch (std::exception& e) {
17943       {
17944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (...) {
17947       {
17948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17949       };
17950     }
17951   }
17952   jresult = new Dali::Handle((const Dali::Handle &)result);
17953   return jresult;
17954 }
17955
17956
17957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_Supports(void * jarg1, int jarg2) {
17958   unsigned int jresult ;
17959   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17960   Dali::Handle::Capability arg2 ;
17961   bool result;
17962
17963   arg1 = (Dali::Handle *)jarg1;
17964   arg2 = (Dali::Handle::Capability)jarg2;
17965   {
17966     try {
17967       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17968     } catch (std::out_of_range& e) {
17969       {
17970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17971       };
17972     } catch (std::exception& e) {
17973       {
17974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (...) {
17977       {
17978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17979       };
17980     }
17981   }
17982   jresult = result;
17983   return jresult;
17984 }
17985
17986
17987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyCount(void * jarg1) {
17988   unsigned int jresult ;
17989   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17990   unsigned int result;
17991
17992   arg1 = (Dali::Handle *)jarg1;
17993   {
17994     try {
17995       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17996     } catch (std::out_of_range& e) {
17997       {
17998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17999       };
18000     } catch (std::exception& e) {
18001       {
18002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (...) {
18005       {
18006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18007       };
18008     }
18009   }
18010   jresult = result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Handle_GetPropertyName(void * jarg1, int jarg2) {
18016   char * jresult ;
18017   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18018   Dali::Property::Index arg2 ;
18019   std::string result;
18020
18021   arg1 = (Dali::Handle *)jarg1;
18022   arg2 = (Dali::Property::Index)jarg2;
18023   {
18024     try {
18025       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18026     } catch (std::out_of_range& e) {
18027       {
18028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (std::exception& e) {
18031       {
18032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18033       };
18034     } catch (...) {
18035       {
18036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18037       };
18038     }
18039   }
18040   jresult = SWIG_csharp_string_callback((&result)->c_str());
18041   return jresult;
18042 }
18043
18044
18045 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18046   int jresult ;
18047   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18048   std::string *arg2 = 0 ;
18049   Dali::Property::Index result;
18050
18051   arg1 = (Dali::Handle *)jarg1;
18052   if (!jarg2) {
18053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18054     return 0;
18055   }
18056   std::string arg2_str(jarg2);
18057   arg2 = &arg2_str;
18058   {
18059     try {
18060       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18061     } catch (std::out_of_range& e) {
18062       {
18063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18064       };
18065     } catch (std::exception& e) {
18066       {
18067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18068       };
18069     } catch (...) {
18070       {
18071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18072       };
18073     }
18074   }
18075   jresult = result;
18076
18077   //argout typemap for const std::string&
18078
18079   return jresult;
18080 }
18081
18082
18083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18084   unsigned int jresult ;
18085   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18086   Dali::Property::Index arg2 ;
18087   bool result;
18088
18089   arg1 = (Dali::Handle *)jarg1;
18090   arg2 = (Dali::Property::Index)jarg2;
18091   {
18092     try {
18093       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18094     } catch (std::out_of_range& e) {
18095       {
18096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (std::exception& e) {
18099       {
18100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18101       };
18102     } catch (...) {
18103       {
18104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18105       };
18106     }
18107   }
18108   jresult = result;
18109   return jresult;
18110 }
18111
18112
18113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18114   unsigned int jresult ;
18115   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18116   Dali::Property::Index arg2 ;
18117   bool result;
18118
18119   arg1 = (Dali::Handle *)jarg1;
18120   arg2 = (Dali::Property::Index)jarg2;
18121   {
18122     try {
18123       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18124     } catch (std::out_of_range& e) {
18125       {
18126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18127       };
18128     } catch (std::exception& e) {
18129       {
18130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18131       };
18132     } catch (...) {
18133       {
18134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18135       };
18136     }
18137   }
18138   jresult = result;
18139   return jresult;
18140 }
18141
18142
18143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18144   unsigned int jresult ;
18145   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18146   Dali::Property::Index arg2 ;
18147   bool result;
18148
18149   arg1 = (Dali::Handle *)jarg1;
18150   arg2 = (Dali::Property::Index)jarg2;
18151   {
18152     try {
18153       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18154     } catch (std::out_of_range& e) {
18155       {
18156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18157       };
18158     } catch (std::exception& e) {
18159       {
18160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (...) {
18163       {
18164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18165       };
18166     }
18167   }
18168   jresult = result;
18169   return jresult;
18170 }
18171
18172
18173 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyType(void * jarg1, int jarg2) {
18174   int jresult ;
18175   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18176   Dali::Property::Index arg2 ;
18177   Dali::Property::Type result;
18178
18179   arg1 = (Dali::Handle *)jarg1;
18180   arg2 = (Dali::Property::Index)jarg2;
18181   {
18182     try {
18183       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18184     } catch (std::out_of_range& e) {
18185       {
18186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18187       };
18188     } catch (std::exception& e) {
18189       {
18190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18191       };
18192     } catch (...) {
18193       {
18194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18195       };
18196     }
18197   }
18198   jresult = (int)result;
18199   return jresult;
18200 }
18201
18202
18203 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18204   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18205   Dali::Property::Index arg2 ;
18206   Dali::Property::Value *arg3 = 0 ;
18207
18208   arg1 = (Dali::Handle *)jarg1;
18209   arg2 = (Dali::Property::Index)jarg2;
18210   arg3 = (Dali::Property::Value *)jarg3;
18211   if (!arg3) {
18212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18213     return ;
18214   }
18215   {
18216     try {
18217       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18218     } catch (std::out_of_range& e) {
18219       {
18220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18221       };
18222     } catch (std::exception& e) {
18223       {
18224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18225       };
18226     } catch (...) {
18227       {
18228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18229       };
18230     }
18231   }
18232 }
18233
18234
18235 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18236   int jresult ;
18237   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18238   std::string *arg2 = 0 ;
18239   Dali::Property::Value *arg3 = 0 ;
18240   Dali::Property::Index result;
18241
18242   arg1 = (Dali::Handle *)jarg1;
18243   if (!jarg2) {
18244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18245     return 0;
18246   }
18247   std::string arg2_str(jarg2);
18248   arg2 = &arg2_str;
18249   arg3 = (Dali::Property::Value *)jarg3;
18250   if (!arg3) {
18251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18252     return 0;
18253   }
18254   {
18255     try {
18256       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18257     } catch (std::out_of_range& e) {
18258       {
18259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18260       };
18261     } catch (std::exception& e) {
18262       {
18263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18264       };
18265     } catch (...) {
18266       {
18267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18268       };
18269     }
18270   }
18271   jresult = result;
18272
18273   //argout typemap for const std::string&
18274
18275   return jresult;
18276 }
18277
18278
18279 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18280   int jresult ;
18281   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18282   std::string *arg2 = 0 ;
18283   Dali::Property::Value *arg3 = 0 ;
18284   Dali::Property::AccessMode arg4 ;
18285   Dali::Property::Index result;
18286
18287   arg1 = (Dali::Handle *)jarg1;
18288   if (!jarg2) {
18289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18290     return 0;
18291   }
18292   std::string arg2_str(jarg2);
18293   arg2 = &arg2_str;
18294   arg3 = (Dali::Property::Value *)jarg3;
18295   if (!arg3) {
18296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18297     return 0;
18298   }
18299   arg4 = (Dali::Property::AccessMode)jarg4;
18300   {
18301     try {
18302       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18303     } catch (std::out_of_range& e) {
18304       {
18305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18306       };
18307     } catch (std::exception& e) {
18308       {
18309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18310       };
18311     } catch (...) {
18312       {
18313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18314       };
18315     }
18316   }
18317   jresult = result;
18318
18319   //argout typemap for const std::string&
18320
18321   return jresult;
18322 }
18323
18324
18325 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_GetProperty(void * jarg1, int jarg2) {
18326   void * jresult ;
18327   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18328   Dali::Property::Index arg2 ;
18329   Dali::Property::Value result;
18330
18331   arg1 = (Dali::Handle *)jarg1;
18332   arg2 = (Dali::Property::Index)jarg2;
18333   {
18334     try {
18335       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18336     } catch (std::out_of_range& e) {
18337       {
18338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18339       };
18340     } catch (std::exception& e) {
18341       {
18342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18343       };
18344     } catch (...) {
18345       {
18346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18347       };
18348     }
18349   }
18350   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18351   return jresult;
18352 }
18353
18354
18355 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18357   Dali::Property::IndexContainer *arg2 = 0 ;
18358
18359   arg1 = (Dali::Handle *)jarg1;
18360   arg2 = (Dali::Property::IndexContainer *)jarg2;
18361   if (!arg2) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18363     return ;
18364   }
18365   {
18366     try {
18367       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18368     } catch (std::out_of_range& e) {
18369       {
18370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18371       };
18372     } catch (std::exception& e) {
18373       {
18374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18375       };
18376     } catch (...) {
18377       {
18378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18379       };
18380     }
18381   }
18382 }
18383
18384
18385 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18386   void * jresult ;
18387   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18388   Dali::Property::Index arg2 ;
18389   Dali::PropertyCondition *arg3 = 0 ;
18390   Dali::PropertyNotification result;
18391
18392   arg1 = (Dali::Handle *)jarg1;
18393   arg2 = (Dali::Property::Index)jarg2;
18394   arg3 = (Dali::PropertyCondition *)jarg3;
18395   if (!arg3) {
18396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18397     return 0;
18398   }
18399   {
18400     try {
18401       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18402     } catch (std::out_of_range& e) {
18403       {
18404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18405       };
18406     } catch (std::exception& e) {
18407       {
18408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18409       };
18410     } catch (...) {
18411       {
18412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18413       };
18414     }
18415   }
18416   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18417   return jresult;
18418 }
18419
18420
18421 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18422   void * jresult ;
18423   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18424   Dali::Property::Index arg2 ;
18425   int arg3 ;
18426   Dali::PropertyCondition *arg4 = 0 ;
18427   Dali::PropertyNotification result;
18428
18429   arg1 = (Dali::Handle *)jarg1;
18430   arg2 = (Dali::Property::Index)jarg2;
18431   arg3 = (int)jarg3;
18432   arg4 = (Dali::PropertyCondition *)jarg4;
18433   if (!arg4) {
18434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18435     return 0;
18436   }
18437   {
18438     try {
18439       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18440     } catch (std::out_of_range& e) {
18441       {
18442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18443       };
18444     } catch (std::exception& e) {
18445       {
18446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18447       };
18448     } catch (...) {
18449       {
18450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18451       };
18452     }
18453   }
18454   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18455   return jresult;
18456 }
18457
18458
18459 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18460   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18461   Dali::PropertyNotification arg2 ;
18462   Dali::PropertyNotification *argp2 ;
18463
18464   arg1 = (Dali::Handle *)jarg1;
18465   argp2 = (Dali::PropertyNotification *)jarg2;
18466   if (!argp2) {
18467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18468     return ;
18469   }
18470   arg2 = *argp2;
18471   {
18472     try {
18473       (arg1)->RemovePropertyNotification(arg2);
18474     } catch (std::out_of_range& e) {
18475       {
18476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18477       };
18478     } catch (std::exception& e) {
18479       {
18480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18481       };
18482     } catch (...) {
18483       {
18484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18485       };
18486     }
18487   }
18488 }
18489
18490
18491 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemovePropertyNotifications(void * jarg1) {
18492   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18493
18494   arg1 = (Dali::Handle *)jarg1;
18495   {
18496     try {
18497       (arg1)->RemovePropertyNotifications();
18498     } catch (std::out_of_range& e) {
18499       {
18500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18501       };
18502     } catch (std::exception& e) {
18503       {
18504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18505       };
18506     } catch (...) {
18507       {
18508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18509       };
18510     }
18511   }
18512 }
18513
18514
18515 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18516   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18517
18518   arg1 = (Dali::Handle *)jarg1;
18519   {
18520     try {
18521       (arg1)->RemoveConstraints();
18522     } catch (std::out_of_range& e) {
18523       {
18524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18525       };
18526     } catch (std::exception& e) {
18527       {
18528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18529       };
18530     } catch (...) {
18531       {
18532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18533       };
18534     }
18535   }
18536 }
18537
18538
18539 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18540   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18541   unsigned int arg2 ;
18542
18543   arg1 = (Dali::Handle *)jarg1;
18544   arg2 = (unsigned int)jarg2;
18545   {
18546     try {
18547       (arg1)->RemoveConstraints(arg2);
18548     } catch (std::out_of_range& e) {
18549       {
18550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18551       };
18552     } catch (std::exception& e) {
18553       {
18554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18555       };
18556     } catch (...) {
18557       {
18558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18559       };
18560     }
18561   }
18562 }
18563
18564
18565 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WEIGHT_get() {
18566   int jresult ;
18567   Dali::Property::Index result;
18568
18569   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18570   jresult = result;
18571   return jresult;
18572 }
18573
18574
18575 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_New() {
18576   void * jresult ;
18577   Dali::Handle result;
18578
18579   {
18580     try {
18581       result = Dali::WeightObject::New();
18582     } catch (std::out_of_range& e) {
18583       {
18584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18585       };
18586     } catch (std::exception& e) {
18587       {
18588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18589       };
18590     } catch (...) {
18591       {
18592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18593       };
18594     }
18595   }
18596   jresult = new Dali::Handle((const Dali::Handle &)result);
18597   return jresult;
18598 }
18599
18600
18601 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeInfo__SWIG_0() {
18602   void * jresult ;
18603   Dali::TypeInfo *result = 0 ;
18604
18605   {
18606     try {
18607       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18608     } catch (std::out_of_range& e) {
18609       {
18610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18611       };
18612     } catch (std::exception& e) {
18613       {
18614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18615       };
18616     } catch (...) {
18617       {
18618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18619       };
18620     }
18621   }
18622   jresult = (void *)result;
18623   return jresult;
18624 }
18625
18626
18627 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeInfo(void * jarg1) {
18628   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18629
18630   arg1 = (Dali::TypeInfo *)jarg1;
18631   {
18632     try {
18633       delete arg1;
18634     } catch (std::out_of_range& e) {
18635       {
18636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18637       };
18638     } catch (std::exception& e) {
18639       {
18640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18641       };
18642     } catch (...) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18645       };
18646     }
18647   }
18648 }
18649
18650
18651 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeInfo__SWIG_1(void * jarg1) {
18652   void * jresult ;
18653   Dali::TypeInfo *arg1 = 0 ;
18654   Dali::TypeInfo *result = 0 ;
18655
18656   arg1 = (Dali::TypeInfo *)jarg1;
18657   if (!arg1) {
18658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18659     return 0;
18660   }
18661   {
18662     try {
18663       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18664     } catch (std::out_of_range& e) {
18665       {
18666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18667       };
18668     } catch (std::exception& e) {
18669       {
18670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18671       };
18672     } catch (...) {
18673       {
18674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18675       };
18676     }
18677   }
18678   jresult = (void *)result;
18679   return jresult;
18680 }
18681
18682
18683 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_Assign(void * jarg1, void * jarg2) {
18684   void * jresult ;
18685   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18686   Dali::TypeInfo *arg2 = 0 ;
18687   Dali::TypeInfo *result = 0 ;
18688
18689   arg1 = (Dali::TypeInfo *)jarg1;
18690   arg2 = (Dali::TypeInfo *)jarg2;
18691   if (!arg2) {
18692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18693     return 0;
18694   }
18695   {
18696     try {
18697       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18698     } catch (std::out_of_range& e) {
18699       {
18700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18701       };
18702     } catch (std::exception& e) {
18703       {
18704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18705       };
18706     } catch (...) {
18707       {
18708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18709       };
18710     }
18711   }
18712   jresult = (void *)result;
18713   return jresult;
18714 }
18715
18716
18717 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetName(void * jarg1) {
18718   char * jresult ;
18719   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18720   std::string *result = 0 ;
18721
18722   arg1 = (Dali::TypeInfo *)jarg1;
18723   {
18724     try {
18725       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18726     } catch (std::out_of_range& e) {
18727       {
18728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18729       };
18730     } catch (std::exception& e) {
18731       {
18732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18733       };
18734     } catch (...) {
18735       {
18736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18737       };
18738     }
18739   }
18740   jresult = SWIG_csharp_string_callback(result->c_str());
18741   return jresult;
18742 }
18743
18744
18745 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetBaseName(void * jarg1) {
18746   char * jresult ;
18747   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18748   std::string *result = 0 ;
18749
18750   arg1 = (Dali::TypeInfo *)jarg1;
18751   {
18752     try {
18753       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18754     } catch (std::out_of_range& e) {
18755       {
18756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18757       };
18758     } catch (std::exception& e) {
18759       {
18760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (...) {
18763       {
18764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18765       };
18766     }
18767   }
18768   jresult = SWIG_csharp_string_callback(result->c_str());
18769   return jresult;
18770 }
18771
18772
18773 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_CreateInstance(void * jarg1) {
18774   void * jresult ;
18775   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18776   Dali::BaseHandle result;
18777
18778   arg1 = (Dali::TypeInfo *)jarg1;
18779   {
18780     try {
18781       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18782     } catch (std::out_of_range& e) {
18783       {
18784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18785       };
18786     } catch (std::exception& e) {
18787       {
18788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18789       };
18790     } catch (...) {
18791       {
18792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18793       };
18794     }
18795   }
18796   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_GetCreator(void * jarg1) {
18802   void * jresult ;
18803   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18804   Dali::TypeInfo::CreateFunction result;
18805
18806   arg1 = (Dali::TypeInfo *)jarg1;
18807   {
18808     try {
18809       result = (Dali::TypeInfo::CreateFunction)((Dali::TypeInfo const *)arg1)->GetCreator();
18810     } catch (std::out_of_range& e) {
18811       {
18812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18813       };
18814     } catch (std::exception& e) {
18815       {
18816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (...) {
18819       {
18820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18821       };
18822     }
18823   }
18824   jresult = (void *)result;
18825   return jresult;
18826 }
18827
18828
18829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetActionCount(void * jarg1) {
18830   unsigned long jresult ;
18831   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18832   size_t result;
18833
18834   arg1 = (Dali::TypeInfo *)jarg1;
18835   {
18836     try {
18837       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18838     } catch (std::out_of_range& e) {
18839       {
18840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18841       };
18842     } catch (std::exception& e) {
18843       {
18844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18845       };
18846     } catch (...) {
18847       {
18848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18849       };
18850     }
18851   }
18852   jresult = (unsigned long)result;
18853   return jresult;
18854 }
18855
18856
18857 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18858   char * jresult ;
18859   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18860   size_t arg2 ;
18861   std::string result;
18862
18863   arg1 = (Dali::TypeInfo *)jarg1;
18864   arg2 = (size_t)jarg2;
18865   {
18866     try {
18867       result = (arg1)->GetActionName(arg2);
18868     } catch (std::out_of_range& e) {
18869       {
18870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18871       };
18872     } catch (std::exception& e) {
18873       {
18874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18875       };
18876     } catch (...) {
18877       {
18878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18879       };
18880     }
18881   }
18882   jresult = SWIG_csharp_string_callback((&result)->c_str());
18883   return jresult;
18884 }
18885
18886
18887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetSignalCount(void * jarg1) {
18888   unsigned long jresult ;
18889   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18890   size_t result;
18891
18892   arg1 = (Dali::TypeInfo *)jarg1;
18893   {
18894     try {
18895       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18896     } catch (std::out_of_range& e) {
18897       {
18898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18899       };
18900     } catch (std::exception& e) {
18901       {
18902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18903       };
18904     } catch (...) {
18905       {
18906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18907       };
18908     }
18909   }
18910   jresult = (unsigned long)result;
18911   return jresult;
18912 }
18913
18914
18915 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18916   char * jresult ;
18917   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18918   size_t arg2 ;
18919   std::string result;
18920
18921   arg1 = (Dali::TypeInfo *)jarg1;
18922   arg2 = (size_t)jarg2;
18923   {
18924     try {
18925       result = (arg1)->GetSignalName(arg2);
18926     } catch (std::out_of_range& e) {
18927       {
18928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18929       };
18930     } catch (std::exception& e) {
18931       {
18932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18933       };
18934     } catch (...) {
18935       {
18936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18937       };
18938     }
18939   }
18940   jresult = SWIG_csharp_string_callback((&result)->c_str());
18941   return jresult;
18942 }
18943
18944
18945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyCount(void * jarg1) {
18946   unsigned long jresult ;
18947   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18948   size_t result;
18949
18950   arg1 = (Dali::TypeInfo *)jarg1;
18951   {
18952     try {
18953       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18954     } catch (std::out_of_range& e) {
18955       {
18956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18957       };
18958     } catch (std::exception& e) {
18959       {
18960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18961       };
18962     } catch (...) {
18963       {
18964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18965       };
18966     }
18967   }
18968   jresult = (unsigned long)result;
18969   return jresult;
18970 }
18971
18972
18973 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18974   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18975   Dali::Property::IndexContainer *arg2 = 0 ;
18976
18977   arg1 = (Dali::TypeInfo *)jarg1;
18978   arg2 = (Dali::Property::IndexContainer *)jarg2;
18979   if (!arg2) {
18980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18981     return ;
18982   }
18983   {
18984     try {
18985       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18986     } catch (std::out_of_range& e) {
18987       {
18988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18989       };
18990     } catch (std::exception& e) {
18991       {
18992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18993       };
18994     } catch (...) {
18995       {
18996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18997       };
18998     }
18999   }
19000 }
19001
19002
19003 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19004   char * jresult ;
19005   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19006   Dali::Property::Index arg2 ;
19007   std::string *result = 0 ;
19008
19009   arg1 = (Dali::TypeInfo *)jarg1;
19010   arg2 = (Dali::Property::Index)jarg2;
19011   {
19012     try {
19013       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19014     } catch (std::out_of_range& e) {
19015       {
19016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19017       };
19018     } catch (std::exception& e) {
19019       {
19020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19021       };
19022     } catch (...) {
19023       {
19024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19025       };
19026     }
19027   }
19028   jresult = SWIG_csharp_string_callback(result->c_str());
19029   return jresult;
19030 }
19031
19032
19033 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_Get() {
19034   void * jresult ;
19035   Dali::TypeRegistry result;
19036
19037   {
19038     try {
19039       result = Dali::TypeRegistry::Get();
19040     } catch (std::out_of_range& e) {
19041       {
19042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19043       };
19044     } catch (std::exception& e) {
19045       {
19046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (...) {
19049       {
19050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19051       };
19052     }
19053   }
19054   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19055   return jresult;
19056 }
19057
19058
19059 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_0() {
19060   void * jresult ;
19061   Dali::TypeRegistry *result = 0 ;
19062
19063   {
19064     try {
19065       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19073       };
19074     } catch (...) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19077       };
19078     }
19079   }
19080   jresult = (void *)result;
19081   return jresult;
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeRegistry(void * jarg1) {
19086   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19087
19088   arg1 = (Dali::TypeRegistry *)jarg1;
19089   {
19090     try {
19091       delete arg1;
19092     } catch (std::out_of_range& e) {
19093       {
19094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19095       };
19096     } catch (std::exception& e) {
19097       {
19098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19103       };
19104     }
19105   }
19106 }
19107
19108
19109 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_1(void * jarg1) {
19110   void * jresult ;
19111   Dali::TypeRegistry *arg1 = 0 ;
19112   Dali::TypeRegistry *result = 0 ;
19113
19114   arg1 = (Dali::TypeRegistry *)jarg1;
19115   if (!arg1) {
19116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19117     return 0;
19118   }
19119   {
19120     try {
19121       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19122     } catch (std::out_of_range& e) {
19123       {
19124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19125       };
19126     } catch (std::exception& e) {
19127       {
19128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19129       };
19130     } catch (...) {
19131       {
19132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19133       };
19134     }
19135   }
19136   jresult = (void *)result;
19137   return jresult;
19138 }
19139
19140
19141 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19142   void * jresult ;
19143   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19144   Dali::TypeRegistry *arg2 = 0 ;
19145   Dali::TypeRegistry *result = 0 ;
19146
19147   arg1 = (Dali::TypeRegistry *)jarg1;
19148   arg2 = (Dali::TypeRegistry *)jarg2;
19149   if (!arg2) {
19150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19151     return 0;
19152   }
19153   {
19154     try {
19155       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19156     } catch (std::out_of_range& e) {
19157       {
19158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19159       };
19160     } catch (std::exception& e) {
19161       {
19162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19167       };
19168     }
19169   }
19170   jresult = (void *)result;
19171   return jresult;
19172 }
19173
19174
19175 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19176   void * jresult ;
19177   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19178   std::string *arg2 = 0 ;
19179   Dali::TypeInfo result;
19180
19181   arg1 = (Dali::TypeRegistry *)jarg1;
19182   if (!jarg2) {
19183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19184     return 0;
19185   }
19186   std::string arg2_str(jarg2);
19187   arg2 = &arg2_str;
19188   {
19189     try {
19190       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (...) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19202       };
19203     }
19204   }
19205   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19206
19207   //argout typemap for const std::string&
19208
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19214   void * jresult ;
19215   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19216   std::type_info *arg2 = 0 ;
19217   Dali::TypeInfo result;
19218
19219   arg1 = (Dali::TypeRegistry *)jarg1;
19220   arg2 = (std::type_info *)jarg2;
19221   if (!arg2) {
19222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19223     return 0;
19224   }
19225   {
19226     try {
19227       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19228     } catch (std::out_of_range& e) {
19229       {
19230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19231       };
19232     } catch (std::exception& e) {
19233       {
19234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (...) {
19237       {
19238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19239       };
19240     }
19241   }
19242   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19243   return jresult;
19244 }
19245
19246
19247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeNameCount(void * jarg1) {
19248   unsigned long jresult ;
19249   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19250   size_t result;
19251
19252   arg1 = (Dali::TypeRegistry *)jarg1;
19253   {
19254     try {
19255       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19256     } catch (std::out_of_range& e) {
19257       {
19258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (std::exception& e) {
19261       {
19262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (...) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19267       };
19268     }
19269   }
19270   jresult = (unsigned long)result;
19271   return jresult;
19272 }
19273
19274
19275 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19276   char * jresult ;
19277   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19278   size_t arg2 ;
19279   std::string result;
19280
19281   arg1 = (Dali::TypeRegistry *)jarg1;
19282   arg2 = (size_t)jarg2;
19283   {
19284     try {
19285       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19286     } catch (std::out_of_range& e) {
19287       {
19288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19289       };
19290     } catch (std::exception& e) {
19291       {
19292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19293       };
19294     } catch (...) {
19295       {
19296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19297       };
19298     }
19299   }
19300   jresult = SWIG_csharp_string_callback((&result)->c_str());
19301   return jresult;
19302 }
19303
19304
19305 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_2(void * jarg1) {
19306   void * jresult ;
19307   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19308   Dali::TypeRegistry *result = 0 ;
19309
19310   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19311   {
19312     try {
19313       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (...) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19325       };
19326     }
19327   }
19328   jresult = (void *)result;
19329   return jresult;
19330 }
19331
19332
19333 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19334   void * jresult ;
19335   std::type_info *arg1 = 0 ;
19336   std::type_info *arg2 = 0 ;
19337   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19338   Dali::TypeRegistration *result = 0 ;
19339
19340   arg1 = (std::type_info *)jarg1;
19341   if (!arg1) {
19342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19343     return 0;
19344   }
19345   arg2 = (std::type_info *)jarg2;
19346   if (!arg2) {
19347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19348     return 0;
19349   }
19350   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19351   {
19352     try {
19353       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19354     } catch (std::out_of_range& e) {
19355       {
19356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (std::exception& e) {
19359       {
19360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368   jresult = (void *)result;
19369   return jresult;
19370 }
19371
19372
19373 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19374   void * jresult ;
19375   std::type_info *arg1 = 0 ;
19376   std::type_info *arg2 = 0 ;
19377   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19378   bool arg4 ;
19379   Dali::TypeRegistration *result = 0 ;
19380
19381   arg1 = (std::type_info *)jarg1;
19382   if (!arg1) {
19383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19384     return 0;
19385   }
19386   arg2 = (std::type_info *)jarg2;
19387   if (!arg2) {
19388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19389     return 0;
19390   }
19391   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19392   arg4 = jarg4 ? true : false;
19393   {
19394     try {
19395       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (...) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19407       };
19408     }
19409   }
19410   jresult = (void *)result;
19411   return jresult;
19412 }
19413
19414
19415 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19416   void * jresult ;
19417   std::string *arg1 = 0 ;
19418   std::type_info *arg2 = 0 ;
19419   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19420   Dali::TypeRegistration *result = 0 ;
19421
19422   if (!jarg1) {
19423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19424     return 0;
19425   }
19426   std::string arg1_str(jarg1);
19427   arg1 = &arg1_str;
19428   arg2 = (std::type_info *)jarg2;
19429   if (!arg2) {
19430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19431     return 0;
19432   }
19433   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19434   {
19435     try {
19436       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19437     } catch (std::out_of_range& e) {
19438       {
19439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19440       };
19441     } catch (std::exception& e) {
19442       {
19443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19444       };
19445     } catch (...) {
19446       {
19447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19448       };
19449     }
19450   }
19451   jresult = (void *)result;
19452
19453   //argout typemap for const std::string&
19454
19455   return jresult;
19456 }
19457
19458
19459 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeRegistration_RegisteredName(void * jarg1) {
19460   char * jresult ;
19461   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19462   std::string result;
19463
19464   arg1 = (Dali::TypeRegistration *)jarg1;
19465   {
19466     try {
19467       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19468     } catch (std::out_of_range& e) {
19469       {
19470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19471       };
19472     } catch (std::exception& e) {
19473       {
19474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19475       };
19476     } catch (...) {
19477       {
19478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19479       };
19480     }
19481   }
19482   jresult = SWIG_csharp_string_callback((&result)->c_str());
19483   return jresult;
19484 }
19485
19486
19487 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeRegistration(void * jarg1) {
19488   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19489
19490   arg1 = (Dali::TypeRegistration *)jarg1;
19491   {
19492     try {
19493       delete arg1;
19494     } catch (std::out_of_range& e) {
19495       {
19496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19497       };
19498     } catch (std::exception& e) {
19499       {
19500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19501       };
19502     } catch (...) {
19503       {
19504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19505       };
19506     }
19507   }
19508 }
19509
19510
19511 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19512   void * jresult ;
19513   Dali::TypeRegistration *arg1 = 0 ;
19514   std::string *arg2 = 0 ;
19515   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19516   Dali::SignalConnectorType *result = 0 ;
19517
19518   arg1 = (Dali::TypeRegistration *)jarg1;
19519   if (!arg1) {
19520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19521     return 0;
19522   }
19523   if (!jarg2) {
19524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19525     return 0;
19526   }
19527   std::string arg2_str(jarg2);
19528   arg2 = &arg2_str;
19529   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19530   {
19531     try {
19532       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19533     } catch (std::out_of_range& e) {
19534       {
19535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19536       };
19537     } catch (std::exception& e) {
19538       {
19539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19540       };
19541     } catch (...) {
19542       {
19543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19544       };
19545     }
19546   }
19547   jresult = (void *)result;
19548
19549   //argout typemap for const std::string&
19550
19551   return jresult;
19552 }
19553
19554
19555 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SignalConnectorType(void * jarg1) {
19556   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19557
19558   arg1 = (Dali::SignalConnectorType *)jarg1;
19559   {
19560     try {
19561       delete arg1;
19562     } catch (std::out_of_range& e) {
19563       {
19564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19565       };
19566     } catch (std::exception& e) {
19567       {
19568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19569       };
19570     } catch (...) {
19571       {
19572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19573       };
19574     }
19575   }
19576 }
19577
19578
19579 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19580   void * jresult ;
19581   Dali::TypeRegistration *arg1 = 0 ;
19582   std::string *arg2 = 0 ;
19583   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19584   Dali::TypeAction *result = 0 ;
19585
19586   arg1 = (Dali::TypeRegistration *)jarg1;
19587   if (!arg1) {
19588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19589     return 0;
19590   }
19591   if (!jarg2) {
19592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19593     return 0;
19594   }
19595   std::string arg2_str(jarg2);
19596   arg2 = &arg2_str;
19597   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19598   {
19599     try {
19600       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19601     } catch (std::out_of_range& e) {
19602       {
19603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19604       };
19605     } catch (std::exception& e) {
19606       {
19607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19608       };
19609     } catch (...) {
19610       {
19611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19612       };
19613     }
19614   }
19615   jresult = (void *)result;
19616
19617   //argout typemap for const std::string&
19618
19619   return jresult;
19620 }
19621
19622
19623 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeAction(void * jarg1) {
19624   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19625
19626   arg1 = (Dali::TypeAction *)jarg1;
19627   {
19628     try {
19629       delete arg1;
19630     } catch (std::out_of_range& e) {
19631       {
19632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19633       };
19634     } catch (std::exception& e) {
19635       {
19636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19637       };
19638     } catch (...) {
19639       {
19640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19641       };
19642     }
19643   }
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19648   void * jresult ;
19649   Dali::TypeRegistration *arg1 = 0 ;
19650   std::string *arg2 = 0 ;
19651   Dali::Property::Index arg3 ;
19652   Dali::Property::Type arg4 ;
19653   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19654   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19655   Dali::PropertyRegistration *result = 0 ;
19656
19657   arg1 = (Dali::TypeRegistration *)jarg1;
19658   if (!arg1) {
19659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19660     return 0;
19661   }
19662   if (!jarg2) {
19663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19664     return 0;
19665   }
19666   std::string arg2_str(jarg2);
19667   arg2 = &arg2_str;
19668   arg3 = (Dali::Property::Index)jarg3;
19669   arg4 = (Dali::Property::Type)jarg4;
19670   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19671   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19672   {
19673     try {
19674       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19675     } catch (std::out_of_range& e) {
19676       {
19677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19678       };
19679     } catch (std::exception& e) {
19680       {
19681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19682       };
19683     } catch (...) {
19684       {
19685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19686       };
19687     }
19688   }
19689   jresult = (void *)result;
19690
19691   //argout typemap for const std::string&
19692
19693   return jresult;
19694 }
19695
19696
19697 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyRegistration(void * jarg1) {
19698   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19699
19700   arg1 = (Dali::PropertyRegistration *)jarg1;
19701   {
19702     try {
19703       delete arg1;
19704     } catch (std::out_of_range& e) {
19705       {
19706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19707       };
19708     } catch (std::exception& e) {
19709       {
19710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19711       };
19712     } catch (...) {
19713       {
19714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19715       };
19716     }
19717   }
19718 }
19719
19720
19721 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19722   void * jresult ;
19723   Dali::TypeRegistration *arg1 = 0 ;
19724   std::string *arg2 = 0 ;
19725   Dali::Property::Index arg3 ;
19726   Dali::Property::Type arg4 ;
19727   Dali::AnimatablePropertyRegistration *result = 0 ;
19728
19729   arg1 = (Dali::TypeRegistration *)jarg1;
19730   if (!arg1) {
19731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19732     return 0;
19733   }
19734   if (!jarg2) {
19735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19736     return 0;
19737   }
19738   std::string arg2_str(jarg2);
19739   arg2 = &arg2_str;
19740   arg3 = (Dali::Property::Index)jarg3;
19741   arg4 = (Dali::Property::Type)jarg4;
19742   {
19743     try {
19744       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19745     } catch (std::out_of_range& e) {
19746       {
19747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19748       };
19749     } catch (std::exception& e) {
19750       {
19751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19752       };
19753     } catch (...) {
19754       {
19755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19756       };
19757     }
19758   }
19759   jresult = (void *)result;
19760
19761   //argout typemap for const std::string&
19762
19763   return jresult;
19764 }
19765
19766
19767 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19768   void * jresult ;
19769   Dali::TypeRegistration *arg1 = 0 ;
19770   std::string *arg2 = 0 ;
19771   Dali::Property::Index arg3 ;
19772   Dali::Property::Value *arg4 = 0 ;
19773   Dali::AnimatablePropertyRegistration *result = 0 ;
19774
19775   arg1 = (Dali::TypeRegistration *)jarg1;
19776   if (!arg1) {
19777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19778     return 0;
19779   }
19780   if (!jarg2) {
19781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19782     return 0;
19783   }
19784   std::string arg2_str(jarg2);
19785   arg2 = &arg2_str;
19786   arg3 = (Dali::Property::Index)jarg3;
19787   arg4 = (Dali::Property::Value *)jarg4;
19788   if (!arg4) {
19789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19790     return 0;
19791   }
19792   {
19793     try {
19794       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19795     } catch (std::out_of_range& e) {
19796       {
19797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19798       };
19799     } catch (std::exception& e) {
19800       {
19801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19802       };
19803     } catch (...) {
19804       {
19805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19806       };
19807     }
19808   }
19809   jresult = (void *)result;
19810
19811   //argout typemap for const std::string&
19812
19813   return jresult;
19814 }
19815
19816
19817 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimatablePropertyRegistration(void * jarg1) {
19818   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19819
19820   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19821   {
19822     try {
19823       delete arg1;
19824     } catch (std::out_of_range& e) {
19825       {
19826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19827       };
19828     } catch (std::exception& e) {
19829       {
19830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19831       };
19832     } catch (...) {
19833       {
19834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19835       };
19836     }
19837   }
19838 }
19839
19840
19841 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19842   void * jresult ;
19843   Dali::TypeRegistration *arg1 = 0 ;
19844   std::string *arg2 = 0 ;
19845   Dali::Property::Index arg3 ;
19846   Dali::Property::Index arg4 ;
19847   unsigned int arg5 ;
19848   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19849
19850   arg1 = (Dali::TypeRegistration *)jarg1;
19851   if (!arg1) {
19852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19853     return 0;
19854   }
19855   if (!jarg2) {
19856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19857     return 0;
19858   }
19859   std::string arg2_str(jarg2);
19860   arg2 = &arg2_str;
19861   arg3 = (Dali::Property::Index)jarg3;
19862   arg4 = (Dali::Property::Index)jarg4;
19863   arg5 = (unsigned int)jarg5;
19864   {
19865     try {
19866       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (...) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19878       };
19879     }
19880   }
19881   jresult = (void *)result;
19882
19883   //argout typemap for const std::string&
19884
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19890   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19891
19892   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19893   {
19894     try {
19895       delete arg1;
19896     } catch (std::out_of_range& e) {
19897       {
19898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19899       };
19900     } catch (std::exception& e) {
19901       {
19902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19903       };
19904     } catch (...) {
19905       {
19906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19907       };
19908     }
19909   }
19910 }
19911
19912
19913 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19914   void * jresult ;
19915   Dali::TypeRegistration *arg1 = 0 ;
19916   std::string *arg2 = 0 ;
19917   Dali::Property::Index arg3 ;
19918   Dali::Property::Type arg4 ;
19919   Dali::ChildPropertyRegistration *result = 0 ;
19920
19921   arg1 = (Dali::TypeRegistration *)jarg1;
19922   if (!arg1) {
19923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19924     return 0;
19925   }
19926   if (!jarg2) {
19927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19928     return 0;
19929   }
19930   std::string arg2_str(jarg2);
19931   arg2 = &arg2_str;
19932   arg3 = (Dali::Property::Index)jarg3;
19933   arg4 = (Dali::Property::Type)jarg4;
19934   {
19935     try {
19936       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19937     } catch (std::out_of_range& e) {
19938       {
19939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (std::exception& e) {
19942       {
19943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19944       };
19945     } catch (...) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19948       };
19949     }
19950   }
19951   jresult = (void *)result;
19952
19953   //argout typemap for const std::string&
19954
19955   return jresult;
19956 }
19957
19958
19959 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ChildPropertyRegistration(void * jarg1) {
19960   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19961
19962   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19963   {
19964     try {
19965       delete arg1;
19966     } catch (std::out_of_range& e) {
19967       {
19968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19969       };
19970     } catch (std::exception& e) {
19971       {
19972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19973       };
19974     } catch (...) {
19975       {
19976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19977       };
19978     }
19979   }
19980 }
19981
19982
19983 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginTop_get() {
19984   float jresult ;
19985   float result;
19986
19987   result = (float)(float)Dali::ParentOrigin::TOP;
19988   jresult = result;
19989   return jresult;
19990 }
19991
19992
19993 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginBottom_get() {
19994   float jresult ;
19995   float result;
19996
19997   result = (float)(float)Dali::ParentOrigin::BOTTOM;
19998   jresult = result;
19999   return jresult;
20000 }
20001
20002
20003 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginLeft_get() {
20004   float jresult ;
20005   float result;
20006
20007   result = (float)(float)Dali::ParentOrigin::LEFT;
20008   jresult = result;
20009   return jresult;
20010 }
20011
20012
20013 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginRight_get() {
20014   float jresult ;
20015   float result;
20016
20017   result = (float)(float)Dali::ParentOrigin::RIGHT;
20018   jresult = result;
20019   return jresult;
20020 }
20021
20022
20023 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginMiddle_get() {
20024   float jresult ;
20025   float result;
20026
20027   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20028   jresult = result;
20029   return jresult;
20030 }
20031
20032
20033 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopLeft_get() {
20034   void * jresult ;
20035   Dali::Vector3 *result = 0 ;
20036
20037   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20038   jresult = (void *)result;
20039   return jresult;
20040 }
20041
20042
20043 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopCenter_get() {
20044   void * jresult ;
20045   Dali::Vector3 *result = 0 ;
20046
20047   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20048   jresult = (void *)result;
20049   return jresult;
20050 }
20051
20052
20053 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopRight_get() {
20054   void * jresult ;
20055   Dali::Vector3 *result = 0 ;
20056
20057   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20058   jresult = (void *)result;
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenterLeft_get() {
20064   void * jresult ;
20065   Dali::Vector3 *result = 0 ;
20066
20067   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20068   jresult = (void *)result;
20069   return jresult;
20070 }
20071
20072
20073 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenter_get() {
20074   void * jresult ;
20075   Dali::Vector3 *result = 0 ;
20076
20077   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20078   jresult = (void *)result;
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenterRight_get() {
20084   void * jresult ;
20085   Dali::Vector3 *result = 0 ;
20086
20087   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20088   jresult = (void *)result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomLeft_get() {
20094   void * jresult ;
20095   Dali::Vector3 *result = 0 ;
20096
20097   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20098   jresult = (void *)result;
20099   return jresult;
20100 }
20101
20102
20103 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomCenter_get() {
20104   void * jresult ;
20105   Dali::Vector3 *result = 0 ;
20106
20107   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20108   jresult = (void *)result;
20109   return jresult;
20110 }
20111
20112
20113 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomRight_get() {
20114   void * jresult ;
20115   Dali::Vector3 *result = 0 ;
20116
20117   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20118   jresult = (void *)result;
20119   return jresult;
20120 }
20121
20122
20123 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointTop_get() {
20124   float jresult ;
20125   float result;
20126
20127   result = (float)(float)Dali::AnchorPoint::TOP;
20128   jresult = result;
20129   return jresult;
20130 }
20131
20132
20133 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointBottom_get() {
20134   float jresult ;
20135   float result;
20136
20137   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20138   jresult = result;
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointLeft_get() {
20144   float jresult ;
20145   float result;
20146
20147   result = (float)(float)Dali::AnchorPoint::LEFT;
20148   jresult = result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointRight_get() {
20154   float jresult ;
20155   float result;
20156
20157   result = (float)(float)Dali::AnchorPoint::RIGHT;
20158   jresult = result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointMiddle_get() {
20164   float jresult ;
20165   float result;
20166
20167   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20168   jresult = result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopLeft_get() {
20174   void * jresult ;
20175   Dali::Vector3 *result = 0 ;
20176
20177   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20178   jresult = (void *)result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopCenter_get() {
20184   void * jresult ;
20185   Dali::Vector3 *result = 0 ;
20186
20187   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20188   jresult = (void *)result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopRight_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenterLeft_get() {
20204   void * jresult ;
20205   Dali::Vector3 *result = 0 ;
20206
20207   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenter_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenterRight_get() {
20224   void * jresult ;
20225   Dali::Vector3 *result = 0 ;
20226
20227   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomLeft_get() {
20234   void * jresult ;
20235   Dali::Vector3 *result = 0 ;
20236
20237   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20238   jresult = (void *)result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomCenter_get() {
20244   void * jresult ;
20245   Dali::Vector3 *result = 0 ;
20246
20247   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomRight_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BLACK_get() {
20264   void * jresult ;
20265   Dali::Vector4 *result = 0 ;
20266
20267   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_WHITE_get() {
20274   void * jresult ;
20275   Dali::Vector4 *result = 0 ;
20276
20277   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RED_get() {
20284   void * jresult ;
20285   Dali::Vector4 *result = 0 ;
20286
20287   result = (Dali::Vector4 *)&Dali::Color::RED;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GREEN_get() {
20294   void * jresult ;
20295   Dali::Vector4 *result = 0 ;
20296
20297   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BLUE_get() {
20304   void * jresult ;
20305   Dali::Vector4 *result = 0 ;
20306
20307   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_YELLOW_get() {
20314   void * jresult ;
20315   Dali::Vector4 *result = 0 ;
20316
20317   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20318   jresult = (void *)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_MAGENTA_get() {
20324   void * jresult ;
20325   Dali::Vector4 *result = 0 ;
20326
20327   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CYAN_get() {
20334   void * jresult ;
20335   Dali::Vector4 *result = 0 ;
20336
20337   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TRANSPARENT_get() {
20344   void * jresult ;
20345   Dali::Vector4 *result = 0 ;
20346
20347   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_0_get() {
20354   float jresult ;
20355   float result;
20356
20357   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20358   jresult = result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_1_get() {
20364   float jresult ;
20365   float result;
20366
20367   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20368   jresult = result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_10_get() {
20374   float jresult ;
20375   float result;
20376
20377   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20378   jresult = result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_100_get() {
20384   float jresult ;
20385   float result;
20386
20387   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20388   jresult = result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_1000_get() {
20394   float jresult ;
20395   float result;
20396
20397   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20398   jresult = result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_10000_get() {
20404   float jresult ;
20405   float result;
20406
20407   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20408   jresult = result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_get() {
20414   float jresult ;
20415   float result;
20416
20417   result = (float)(float)Dali::Math::PI;
20418   jresult = result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_2_get() {
20424   float jresult ;
20425   float result;
20426
20427   result = (float)(float)Dali::Math::PI_2;
20428   jresult = result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_4_get() {
20434   float jresult ;
20435   float result;
20436
20437   result = (float)(float)Dali::Math::PI_4;
20438   jresult = result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_OVER_180_get() {
20444   float jresult ;
20445   float result;
20446
20447   result = (float)(float)Dali::Math::PI_OVER_180;
20448   jresult = result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ONE80_OVER_PI_get() {
20454   float jresult ;
20455   float result;
20456
20457   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ResizePolicyDefault_get() {
20464   int jresult ;
20465   Dali::ResizePolicy::Type result;
20466
20467   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20468   jresult = (int)result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Count(void * jarg1) {
20474   unsigned long jresult ;
20475   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20476   Dali::VectorBase::SizeType result;
20477
20478   arg1 = (Dali::VectorBase *)jarg1;
20479   {
20480     try {
20481       result = ((Dali::VectorBase const *)arg1)->Count();
20482     } catch (std::out_of_range& e) {
20483       {
20484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (std::exception& e) {
20487       {
20488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20489       };
20490     } catch (...) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20493       };
20494     }
20495   }
20496   jresult = (unsigned long)result;
20497   return jresult;
20498 }
20499
20500
20501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Size(void * jarg1) {
20502   unsigned long jresult ;
20503   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20504   Dali::VectorBase::SizeType result;
20505
20506   arg1 = (Dali::VectorBase *)jarg1;
20507   {
20508     try {
20509       result = ((Dali::VectorBase const *)arg1)->Size();
20510     } catch (std::out_of_range& e) {
20511       {
20512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20513       };
20514     } catch (std::exception& e) {
20515       {
20516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (...) {
20519       {
20520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20521       };
20522     }
20523   }
20524   jresult = (unsigned long)result;
20525   return jresult;
20526 }
20527
20528
20529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VectorBase_Empty(void * jarg1) {
20530   unsigned int jresult ;
20531   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20532   bool result;
20533
20534   arg1 = (Dali::VectorBase *)jarg1;
20535   {
20536     try {
20537       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20538     } catch (std::out_of_range& e) {
20539       {
20540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20541       };
20542     } catch (std::exception& e) {
20543       {
20544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20545       };
20546     } catch (...) {
20547       {
20548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20549       };
20550     }
20551   }
20552   jresult = result;
20553   return jresult;
20554 }
20555
20556
20557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Capacity(void * jarg1) {
20558   unsigned long jresult ;
20559   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20560   Dali::VectorBase::SizeType result;
20561
20562   arg1 = (Dali::VectorBase *)jarg1;
20563   {
20564     try {
20565       result = ((Dali::VectorBase const *)arg1)->Capacity();
20566     } catch (std::out_of_range& e) {
20567       {
20568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20569       };
20570     } catch (std::exception& e) {
20571       {
20572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20573       };
20574     } catch (...) {
20575       {
20576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20577       };
20578     }
20579   }
20580   jresult = (unsigned long)result;
20581   return jresult;
20582 }
20583
20584
20585 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorBase_Release(void * jarg1) {
20586   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20587
20588   arg1 = (Dali::VectorBase *)jarg1;
20589   {
20590     try {
20591       (arg1)->Release();
20592     } catch (std::out_of_range& e) {
20593       {
20594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20595       };
20596     } catch (std::exception& e) {
20597       {
20598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20603       };
20604     }
20605   }
20606 }
20607
20608
20609 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Image__SWIG_0() {
20610   void * jresult ;
20611   Dali::Image *result = 0 ;
20612
20613   {
20614     try {
20615       result = (Dali::Image *)new Dali::Image();
20616     } catch (std::out_of_range& e) {
20617       {
20618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20619       };
20620     } catch (std::exception& e) {
20621       {
20622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (...) {
20625       {
20626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20627       };
20628     }
20629   }
20630   jresult = (void *)result;
20631   return jresult;
20632 }
20633
20634
20635 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Image(void * jarg1) {
20636   Dali::Image *arg1 = (Dali::Image *) 0 ;
20637
20638   arg1 = (Dali::Image *)jarg1;
20639   {
20640     try {
20641       delete arg1;
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20649       };
20650     } catch (...) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20653       };
20654     }
20655   }
20656 }
20657
20658
20659 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Image__SWIG_1(void * jarg1) {
20660   void * jresult ;
20661   Dali::Image *arg1 = 0 ;
20662   Dali::Image *result = 0 ;
20663
20664   arg1 = (Dali::Image *)jarg1;
20665   if (!arg1) {
20666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20667     return 0;
20668   }
20669   {
20670     try {
20671       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20672     } catch (std::out_of_range& e) {
20673       {
20674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20675       };
20676     } catch (std::exception& e) {
20677       {
20678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20679       };
20680     } catch (...) {
20681       {
20682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20683       };
20684     }
20685   }
20686   jresult = (void *)result;
20687   return jresult;
20688 }
20689
20690
20691 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_Assign(void * jarg1, void * jarg2) {
20692   void * jresult ;
20693   Dali::Image *arg1 = (Dali::Image *) 0 ;
20694   Dali::Image *arg2 = 0 ;
20695   Dali::Image *result = 0 ;
20696
20697   arg1 = (Dali::Image *)jarg1;
20698   arg2 = (Dali::Image *)jarg2;
20699   if (!arg2) {
20700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20701     return 0;
20702   }
20703   {
20704     try {
20705       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20706     } catch (std::out_of_range& e) {
20707       {
20708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20709       };
20710     } catch (std::exception& e) {
20711       {
20712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20713       };
20714     } catch (...) {
20715       {
20716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20717       };
20718     }
20719   }
20720   jresult = (void *)result;
20721   return jresult;
20722 }
20723
20724
20725 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_DownCast(void * jarg1) {
20726   void * jresult ;
20727   Dali::BaseHandle arg1 ;
20728   Dali::BaseHandle *argp1 ;
20729   Dali::Image result;
20730
20731   argp1 = (Dali::BaseHandle *)jarg1;
20732   if (!argp1) {
20733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20734     return 0;
20735   }
20736   arg1 = *argp1;
20737   {
20738     try {
20739       result = Dali::Image::DownCast(arg1);
20740     } catch (std::out_of_range& e) {
20741       {
20742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20743       };
20744     } catch (std::exception& e) {
20745       {
20746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20747       };
20748     } catch (...) {
20749       {
20750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20751       };
20752     }
20753   }
20754   jresult = new Dali::Image((const Dali::Image &)result);
20755   return jresult;
20756 }
20757
20758
20759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Image_GetWidth(void * jarg1) {
20760   unsigned int jresult ;
20761   Dali::Image *arg1 = (Dali::Image *) 0 ;
20762   unsigned int result;
20763
20764   arg1 = (Dali::Image *)jarg1;
20765   {
20766     try {
20767       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20768     } catch (std::out_of_range& e) {
20769       {
20770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20771       };
20772     } catch (std::exception& e) {
20773       {
20774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20775       };
20776     } catch (...) {
20777       {
20778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20779       };
20780     }
20781   }
20782   jresult = result;
20783   return jresult;
20784 }
20785
20786
20787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Image_GetHeight(void * jarg1) {
20788   unsigned int jresult ;
20789   Dali::Image *arg1 = (Dali::Image *) 0 ;
20790   unsigned int result;
20791
20792   arg1 = (Dali::Image *)jarg1;
20793   {
20794     try {
20795       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20796     } catch (std::out_of_range& e) {
20797       {
20798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20799       };
20800     } catch (std::exception& e) {
20801       {
20802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20803       };
20804     } catch (...) {
20805       {
20806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20807       };
20808     }
20809   }
20810   jresult = result;
20811   return jresult;
20812 }
20813
20814
20815 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_UploadedSignal(void * jarg1) {
20816   void * jresult ;
20817   Dali::Image *arg1 = (Dali::Image *) 0 ;
20818   Dali::Image::ImageSignalType *result = 0 ;
20819
20820   arg1 = (Dali::Image *)jarg1;
20821   {
20822     try {
20823       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20824     } catch (std::out_of_range& e) {
20825       {
20826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20827       };
20828     } catch (std::exception& e) {
20829       {
20830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (...) {
20833       {
20834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20835       };
20836     }
20837   }
20838   jresult = (void *)result;
20839   return jresult;
20840 }
20841
20842
20843 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FIRST_VALID_PIXEL_FORMAT_get() {
20844   int jresult ;
20845   Dali::Pixel::Format result;
20846
20847   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20848   jresult = (int)result;
20849   return jresult;
20850 }
20851
20852
20853 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LAST_VALID_PIXEL_FORMAT_get() {
20854   int jresult ;
20855   Dali::Pixel::Format result;
20856
20857   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20858   jresult = (int)result;
20859   return jresult;
20860 }
20861
20862
20863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_HasAlpha(int jarg1) {
20864   unsigned int jresult ;
20865   Dali::Pixel::Format arg1 ;
20866   bool result;
20867
20868   arg1 = (Dali::Pixel::Format)jarg1;
20869   {
20870     try {
20871       result = (bool)Dali::Pixel::HasAlpha(arg1);
20872     } catch (std::out_of_range& e) {
20873       {
20874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (std::exception& e) {
20877       {
20878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886   jresult = result;
20887   return jresult;
20888 }
20889
20890
20891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GetBytesPerPixel(int jarg1) {
20892   unsigned int jresult ;
20893   Dali::Pixel::Format arg1 ;
20894   unsigned int result;
20895
20896   arg1 = (Dali::Pixel::Format)jarg1;
20897   {
20898     try {
20899       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20907       };
20908     } catch (...) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20911       };
20912     }
20913   }
20914   jresult = result;
20915   return jresult;
20916 }
20917
20918
20919 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
20920   Dali::Pixel::Format arg1 ;
20921   int *arg2 = 0 ;
20922   int *arg3 = 0 ;
20923
20924   arg1 = (Dali::Pixel::Format)jarg1;
20925   arg2 = (int *)jarg2;
20926   if (!arg2) {
20927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
20928     return ;
20929   }
20930   arg3 = (int *)jarg3;
20931   if (!arg3) {
20932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
20933     return ;
20934   }
20935   {
20936     try {
20937       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
20938     } catch (std::out_of_range& e) {
20939       {
20940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20941       };
20942     } catch (std::exception& e) {
20943       {
20944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20945       };
20946     } catch (...) {
20947       {
20948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20949       };
20950     }
20951   }
20952 }
20953
20954
20955 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
20956   void * jresult ;
20957   unsigned char *arg1 = (unsigned char *) 0 ;
20958   unsigned int arg2 ;
20959   unsigned int arg3 ;
20960   unsigned int arg4 ;
20961   Dali::Pixel::Format arg5 ;
20962   Dali::PixelData::ReleaseFunction arg6 ;
20963   Dali::PixelData result;
20964
20965   arg1 = jarg1;
20966   arg2 = (unsigned int)jarg2;
20967   arg3 = (unsigned int)jarg3;
20968   arg4 = (unsigned int)jarg4;
20969   arg5 = (Dali::Pixel::Format)jarg5;
20970   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
20971   {
20972     try {
20973       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
20974     } catch (std::out_of_range& e) {
20975       {
20976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20977       };
20978     } catch (std::exception& e) {
20979       {
20980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20981       };
20982     } catch (...) {
20983       {
20984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20985       };
20986     }
20987   }
20988   jresult = new Dali::PixelData((const Dali::PixelData &)result);
20989
20990
20991   return jresult;
20992 }
20993
20994
20995 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PixelData__SWIG_0() {
20996   void * jresult ;
20997   Dali::PixelData *result = 0 ;
20998
20999   {
21000     try {
21001       result = (Dali::PixelData *)new Dali::PixelData();
21002     } catch (std::out_of_range& e) {
21003       {
21004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21005       };
21006     } catch (std::exception& e) {
21007       {
21008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21009       };
21010     } catch (...) {
21011       {
21012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21013       };
21014     }
21015   }
21016   jresult = (void *)result;
21017   return jresult;
21018 }
21019
21020
21021 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PixelData(void * jarg1) {
21022   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21023
21024   arg1 = (Dali::PixelData *)jarg1;
21025   {
21026     try {
21027       delete arg1;
21028     } catch (std::out_of_range& e) {
21029       {
21030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21031       };
21032     } catch (std::exception& e) {
21033       {
21034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21035       };
21036     } catch (...) {
21037       {
21038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21039       };
21040     }
21041   }
21042 }
21043
21044
21045 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PixelData__SWIG_1(void * jarg1) {
21046   void * jresult ;
21047   Dali::PixelData *arg1 = 0 ;
21048   Dali::PixelData *result = 0 ;
21049
21050   arg1 = (Dali::PixelData *)jarg1;
21051   if (!arg1) {
21052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21053     return 0;
21054   }
21055   {
21056     try {
21057       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21058     } catch (std::out_of_range& e) {
21059       {
21060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21061       };
21062     } catch (std::exception& e) {
21063       {
21064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21065       };
21066     } catch (...) {
21067       {
21068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21069       };
21070     }
21071   }
21072   jresult = (void *)result;
21073   return jresult;
21074 }
21075
21076
21077 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PixelData_Assign(void * jarg1, void * jarg2) {
21078   void * jresult ;
21079   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21080   Dali::PixelData *arg2 = 0 ;
21081   Dali::PixelData *result = 0 ;
21082
21083   arg1 = (Dali::PixelData *)jarg1;
21084   arg2 = (Dali::PixelData *)jarg2;
21085   if (!arg2) {
21086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21087     return 0;
21088   }
21089   {
21090     try {
21091       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21092     } catch (std::out_of_range& e) {
21093       {
21094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21095       };
21096     } catch (std::exception& e) {
21097       {
21098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21099       };
21100     } catch (...) {
21101       {
21102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21103       };
21104     }
21105   }
21106   jresult = (void *)result;
21107   return jresult;
21108 }
21109
21110
21111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PixelData_GetWidth(void * jarg1) {
21112   unsigned int jresult ;
21113   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21114   unsigned int result;
21115
21116   arg1 = (Dali::PixelData *)jarg1;
21117   {
21118     try {
21119       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21120     } catch (std::out_of_range& e) {
21121       {
21122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21123       };
21124     } catch (std::exception& e) {
21125       {
21126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21127       };
21128     } catch (...) {
21129       {
21130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21131       };
21132     }
21133   }
21134   jresult = result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PixelData_GetHeight(void * jarg1) {
21140   unsigned int jresult ;
21141   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21142   unsigned int result;
21143
21144   arg1 = (Dali::PixelData *)jarg1;
21145   {
21146     try {
21147       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21148     } catch (std::out_of_range& e) {
21149       {
21150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21151       };
21152     } catch (std::exception& e) {
21153       {
21154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (...) {
21157       {
21158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21159       };
21160     }
21161   }
21162   jresult = result;
21163   return jresult;
21164 }
21165
21166
21167 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PixelData_GetPixelFormat(void * jarg1) {
21168   int jresult ;
21169   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21170   Dali::Pixel::Format result;
21171
21172   arg1 = (Dali::PixelData *)jarg1;
21173   {
21174     try {
21175       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21176     } catch (std::out_of_range& e) {
21177       {
21178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21179       };
21180     } catch (std::exception& e) {
21181       {
21182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21183       };
21184     } catch (...) {
21185       {
21186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21187       };
21188     }
21189   }
21190   jresult = (int)result;
21191   return jresult;
21192 }
21193
21194
21195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_X_get() {
21196   unsigned int jresult ;
21197   unsigned int result;
21198
21199   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21200   jresult = result;
21201   return jresult;
21202 }
21203
21204
21205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_X_get() {
21206   unsigned int jresult ;
21207   unsigned int result;
21208
21209   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21210   jresult = result;
21211   return jresult;
21212 }
21213
21214
21215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_Y_get() {
21216   unsigned int jresult ;
21217   unsigned int result;
21218
21219   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21220   jresult = result;
21221   return jresult;
21222 }
21223
21224
21225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_Y_get() {
21226   unsigned int jresult ;
21227   unsigned int result;
21228
21229   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21230   jresult = result;
21231   return jresult;
21232 }
21233
21234
21235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_Z_get() {
21236   unsigned int jresult ;
21237   unsigned int result;
21238
21239   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21240   jresult = result;
21241   return jresult;
21242 }
21243
21244
21245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_Z_get() {
21246   unsigned int jresult ;
21247   unsigned int result;
21248
21249   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21250   jresult = result;
21251   return jresult;
21252 }
21253
21254
21255 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21256   void * jresult ;
21257   Dali::TextureType::Type arg1 ;
21258   Dali::Pixel::Format arg2 ;
21259   unsigned int arg3 ;
21260   unsigned int arg4 ;
21261   Dali::Texture result;
21262
21263   arg1 = (Dali::TextureType::Type)jarg1;
21264   arg2 = (Dali::Pixel::Format)jarg2;
21265   arg3 = (unsigned int)jarg3;
21266   arg4 = (unsigned int)jarg4;
21267   {
21268     try {
21269       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21270     } catch (std::out_of_range& e) {
21271       {
21272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21273       };
21274     } catch (std::exception& e) {
21275       {
21276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21277       };
21278     } catch (...) {
21279       {
21280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21281       };
21282     }
21283   }
21284   jresult = new Dali::Texture((const Dali::Texture &)result);
21285   return jresult;
21286 }
21287
21288
21289 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_New__SWIG_1(void * jarg1) {
21290   void * jresult ;
21291   NativeImageInterface *arg1 = 0 ;
21292   Dali::Texture result;
21293
21294   arg1 = (NativeImageInterface *)jarg1;
21295   if (!arg1) {
21296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21297     return 0;
21298   }
21299   {
21300     try {
21301       result = Dali::Texture::New(*arg1);
21302     } catch (std::out_of_range& e) {
21303       {
21304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21305       };
21306     } catch (std::exception& e) {
21307       {
21308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21309       };
21310     } catch (...) {
21311       {
21312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21313       };
21314     }
21315   }
21316   jresult = new Dali::Texture((const Dali::Texture &)result);
21317   return jresult;
21318 }
21319
21320
21321 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Texture__SWIG_0() {
21322   void * jresult ;
21323   Dali::Texture *result = 0 ;
21324
21325   {
21326     try {
21327       result = (Dali::Texture *)new Dali::Texture();
21328     } catch (std::out_of_range& e) {
21329       {
21330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21331       };
21332     } catch (std::exception& e) {
21333       {
21334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21335       };
21336     } catch (...) {
21337       {
21338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21339       };
21340     }
21341   }
21342   jresult = (void *)result;
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Texture(void * jarg1) {
21348   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21349
21350   arg1 = (Dali::Texture *)jarg1;
21351   {
21352     try {
21353       delete arg1;
21354     } catch (std::out_of_range& e) {
21355       {
21356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21357       };
21358     } catch (std::exception& e) {
21359       {
21360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21361       };
21362     } catch (...) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21365       };
21366     }
21367   }
21368 }
21369
21370
21371 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Texture__SWIG_1(void * jarg1) {
21372   void * jresult ;
21373   Dali::Texture *arg1 = 0 ;
21374   Dali::Texture *result = 0 ;
21375
21376   arg1 = (Dali::Texture *)jarg1;
21377   if (!arg1) {
21378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21379     return 0;
21380   }
21381   {
21382     try {
21383       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21384     } catch (std::out_of_range& e) {
21385       {
21386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21387       };
21388     } catch (std::exception& e) {
21389       {
21390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21391       };
21392     } catch (...) {
21393       {
21394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21395       };
21396     }
21397   }
21398   jresult = (void *)result;
21399   return jresult;
21400 }
21401
21402
21403 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_DownCast(void * jarg1) {
21404   void * jresult ;
21405   Dali::BaseHandle arg1 ;
21406   Dali::BaseHandle *argp1 ;
21407   Dali::Texture result;
21408
21409   argp1 = (Dali::BaseHandle *)jarg1;
21410   if (!argp1) {
21411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21412     return 0;
21413   }
21414   arg1 = *argp1;
21415   {
21416     try {
21417       result = Dali::Texture::DownCast(arg1);
21418     } catch (std::out_of_range& e) {
21419       {
21420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21421       };
21422     } catch (std::exception& e) {
21423       {
21424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (...) {
21427       {
21428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21429       };
21430     }
21431   }
21432   jresult = new Dali::Texture((const Dali::Texture &)result);
21433   return jresult;
21434 }
21435
21436
21437 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_Assign(void * jarg1, void * jarg2) {
21438   void * jresult ;
21439   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21440   Dali::Texture *arg2 = 0 ;
21441   Dali::Texture *result = 0 ;
21442
21443   arg1 = (Dali::Texture *)jarg1;
21444   arg2 = (Dali::Texture *)jarg2;
21445   if (!arg2) {
21446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21447     return 0;
21448   }
21449   {
21450     try {
21451       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (...) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21463       };
21464     }
21465   }
21466   jresult = (void *)result;
21467   return jresult;
21468 }
21469
21470
21471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21472   unsigned int jresult ;
21473   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21474   Dali::PixelData arg2 ;
21475   Dali::PixelData *argp2 ;
21476   bool result;
21477
21478   arg1 = (Dali::Texture *)jarg1;
21479   argp2 = (Dali::PixelData *)jarg2;
21480   if (!argp2) {
21481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21482     return 0;
21483   }
21484   arg2 = *argp2;
21485   {
21486     try {
21487       result = (bool)(arg1)->Upload(arg2);
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (...) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21499       };
21500     }
21501   }
21502   jresult = result;
21503   return jresult;
21504 }
21505
21506
21507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_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) {
21508   unsigned int jresult ;
21509   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21510   Dali::PixelData arg2 ;
21511   unsigned int arg3 ;
21512   unsigned int arg4 ;
21513   unsigned int arg5 ;
21514   unsigned int arg6 ;
21515   unsigned int arg7 ;
21516   unsigned int arg8 ;
21517   Dali::PixelData *argp2 ;
21518   bool result;
21519
21520   arg1 = (Dali::Texture *)jarg1;
21521   argp2 = (Dali::PixelData *)jarg2;
21522   if (!argp2) {
21523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21524     return 0;
21525   }
21526   arg2 = *argp2;
21527   arg3 = (unsigned int)jarg3;
21528   arg4 = (unsigned int)jarg4;
21529   arg5 = (unsigned int)jarg5;
21530   arg6 = (unsigned int)jarg6;
21531   arg7 = (unsigned int)jarg7;
21532   arg8 = (unsigned int)jarg8;
21533   {
21534     try {
21535       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21536     } catch (std::out_of_range& e) {
21537       {
21538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21539       };
21540     } catch (std::exception& e) {
21541       {
21542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21543       };
21544     } catch (...) {
21545       {
21546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21547       };
21548     }
21549   }
21550   jresult = result;
21551   return jresult;
21552 }
21553
21554
21555 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Texture_GenerateMipmaps(void * jarg1) {
21556   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21557
21558   arg1 = (Dali::Texture *)jarg1;
21559   {
21560     try {
21561       (arg1)->GenerateMipmaps();
21562     } catch (std::out_of_range& e) {
21563       {
21564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21565       };
21566     } catch (std::exception& e) {
21567       {
21568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21569       };
21570     } catch (...) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21573       };
21574     }
21575   }
21576 }
21577
21578
21579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_GetWidth(void * jarg1) {
21580   unsigned int jresult ;
21581   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21582   unsigned int result;
21583
21584   arg1 = (Dali::Texture *)jarg1;
21585   {
21586     try {
21587       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21588     } catch (std::out_of_range& e) {
21589       {
21590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21591       };
21592     } catch (std::exception& e) {
21593       {
21594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (...) {
21597       {
21598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21599       };
21600     }
21601   }
21602   jresult = result;
21603   return jresult;
21604 }
21605
21606
21607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_GetHeight(void * jarg1) {
21608   unsigned int jresult ;
21609   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21610   unsigned int result;
21611
21612   arg1 = (Dali::Texture *)jarg1;
21613   {
21614     try {
21615       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21616     } catch (std::out_of_range& e) {
21617       {
21618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (std::exception& e) {
21621       {
21622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21623       };
21624     } catch (...) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21627       };
21628     }
21629   }
21630   jresult = result;
21631   return jresult;
21632 }
21633
21634
21635 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_New() {
21636   void * jresult ;
21637   Dali::Sampler result;
21638
21639   {
21640     try {
21641       result = Dali::Sampler::New();
21642     } catch (std::out_of_range& e) {
21643       {
21644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21645       };
21646     } catch (std::exception& e) {
21647       {
21648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21649       };
21650     } catch (...) {
21651       {
21652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21653       };
21654     }
21655   }
21656   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21657   return jresult;
21658 }
21659
21660
21661 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Sampler__SWIG_0() {
21662   void * jresult ;
21663   Dali::Sampler *result = 0 ;
21664
21665   {
21666     try {
21667       result = (Dali::Sampler *)new Dali::Sampler();
21668     } catch (std::out_of_range& e) {
21669       {
21670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21671       };
21672     } catch (std::exception& e) {
21673       {
21674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21675       };
21676     } catch (...) {
21677       {
21678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21679       };
21680     }
21681   }
21682   jresult = (void *)result;
21683   return jresult;
21684 }
21685
21686
21687 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Sampler(void * jarg1) {
21688   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21689
21690   arg1 = (Dali::Sampler *)jarg1;
21691   {
21692     try {
21693       delete arg1;
21694     } catch (std::out_of_range& e) {
21695       {
21696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21697       };
21698     } catch (std::exception& e) {
21699       {
21700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21701       };
21702     } catch (...) {
21703       {
21704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21705       };
21706     }
21707   }
21708 }
21709
21710
21711 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Sampler__SWIG_1(void * jarg1) {
21712   void * jresult ;
21713   Dali::Sampler *arg1 = 0 ;
21714   Dali::Sampler *result = 0 ;
21715
21716   arg1 = (Dali::Sampler *)jarg1;
21717   if (!arg1) {
21718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21719     return 0;
21720   }
21721   {
21722     try {
21723       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21724     } catch (std::out_of_range& e) {
21725       {
21726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21727       };
21728     } catch (std::exception& e) {
21729       {
21730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21731       };
21732     } catch (...) {
21733       {
21734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21735       };
21736     }
21737   }
21738   jresult = (void *)result;
21739   return jresult;
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_DownCast(void * jarg1) {
21744   void * jresult ;
21745   Dali::BaseHandle arg1 ;
21746   Dali::BaseHandle *argp1 ;
21747   Dali::Sampler result;
21748
21749   argp1 = (Dali::BaseHandle *)jarg1;
21750   if (!argp1) {
21751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21752     return 0;
21753   }
21754   arg1 = *argp1;
21755   {
21756     try {
21757       result = Dali::Sampler::DownCast(arg1);
21758     } catch (std::out_of_range& e) {
21759       {
21760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21761       };
21762     } catch (std::exception& e) {
21763       {
21764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21765       };
21766     } catch (...) {
21767       {
21768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21769       };
21770     }
21771   }
21772   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21773   return jresult;
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_Assign(void * jarg1, void * jarg2) {
21778   void * jresult ;
21779   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21780   Dali::Sampler *arg2 = 0 ;
21781   Dali::Sampler *result = 0 ;
21782
21783   arg1 = (Dali::Sampler *)jarg1;
21784   arg2 = (Dali::Sampler *)jarg2;
21785   if (!arg2) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (...) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21803       };
21804     }
21805   }
21806   jresult = (void *)result;
21807   return jresult;
21808 }
21809
21810
21811 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21812   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21813   Dali::FilterMode::Type arg2 ;
21814   Dali::FilterMode::Type arg3 ;
21815
21816   arg1 = (Dali::Sampler *)jarg1;
21817   arg2 = (Dali::FilterMode::Type)jarg2;
21818   arg3 = (Dali::FilterMode::Type)jarg3;
21819   {
21820     try {
21821       (arg1)->SetFilterMode(arg2,arg3);
21822     } catch (std::out_of_range& e) {
21823       {
21824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21825       };
21826     } catch (std::exception& e) {
21827       {
21828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21829       };
21830     } catch (...) {
21831       {
21832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21833       };
21834     }
21835   }
21836 }
21837
21838
21839 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21840   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21841   Dali::WrapMode::Type arg2 ;
21842   Dali::WrapMode::Type arg3 ;
21843
21844   arg1 = (Dali::Sampler *)jarg1;
21845   arg2 = (Dali::WrapMode::Type)jarg2;
21846   arg3 = (Dali::WrapMode::Type)jarg3;
21847   {
21848     try {
21849       (arg1)->SetWrapMode(arg2,arg3);
21850     } catch (std::out_of_range& e) {
21851       {
21852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21853       };
21854     } catch (std::exception& e) {
21855       {
21856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21857       };
21858     } catch (...) {
21859       {
21860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21861       };
21862     }
21863   }
21864 }
21865
21866
21867 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21868   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21869   Dali::WrapMode::Type arg2 ;
21870   Dali::WrapMode::Type arg3 ;
21871   Dali::WrapMode::Type arg4 ;
21872
21873   arg1 = (Dali::Sampler *)jarg1;
21874   arg2 = (Dali::WrapMode::Type)jarg2;
21875   arg3 = (Dali::WrapMode::Type)jarg3;
21876   arg4 = (Dali::WrapMode::Type)jarg4;
21877   {
21878     try {
21879       (arg1)->SetWrapMode(arg2,arg3,arg4);
21880     } catch (std::out_of_range& e) {
21881       {
21882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21883       };
21884     } catch (std::exception& e) {
21885       {
21886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21887       };
21888     } catch (...) {
21889       {
21890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21891       };
21892     }
21893   }
21894 }
21895
21896
21897 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_New() {
21898   void * jresult ;
21899   Dali::TextureSet result;
21900
21901   {
21902     try {
21903       result = Dali::TextureSet::New();
21904     } catch (std::out_of_range& e) {
21905       {
21906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21907       };
21908     } catch (std::exception& e) {
21909       {
21910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (...) {
21913       {
21914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21915       };
21916     }
21917   }
21918   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
21919   return jresult;
21920 }
21921
21922
21923 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextureSet__SWIG_0() {
21924   void * jresult ;
21925   Dali::TextureSet *result = 0 ;
21926
21927   {
21928     try {
21929       result = (Dali::TextureSet *)new Dali::TextureSet();
21930     } catch (std::out_of_range& e) {
21931       {
21932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21933       };
21934     } catch (std::exception& e) {
21935       {
21936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21937       };
21938     } catch (...) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21941       };
21942     }
21943   }
21944   jresult = (void *)result;
21945   return jresult;
21946 }
21947
21948
21949 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextureSet(void * jarg1) {
21950   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
21951
21952   arg1 = (Dali::TextureSet *)jarg1;
21953   {
21954     try {
21955       delete arg1;
21956     } catch (std::out_of_range& e) {
21957       {
21958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21959       };
21960     } catch (std::exception& e) {
21961       {
21962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21963       };
21964     } catch (...) {
21965       {
21966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21967       };
21968     }
21969   }
21970 }
21971
21972
21973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextureSet__SWIG_1(void * jarg1) {
21974   void * jresult ;
21975   Dali::TextureSet *arg1 = 0 ;
21976   Dali::TextureSet *result = 0 ;
21977
21978   arg1 = (Dali::TextureSet *)jarg1;
21979   if (!arg1) {
21980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
21981     return 0;
21982   }
21983   {
21984     try {
21985       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
21986     } catch (std::out_of_range& e) {
21987       {
21988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21989       };
21990     } catch (std::exception& e) {
21991       {
21992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (...) {
21995       {
21996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21997       };
21998     }
21999   }
22000   jresult = (void *)result;
22001   return jresult;
22002 }
22003
22004
22005 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_DownCast(void * jarg1) {
22006   void * jresult ;
22007   Dali::BaseHandle arg1 ;
22008   Dali::BaseHandle *argp1 ;
22009   Dali::TextureSet result;
22010
22011   argp1 = (Dali::BaseHandle *)jarg1;
22012   if (!argp1) {
22013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22014     return 0;
22015   }
22016   arg1 = *argp1;
22017   {
22018     try {
22019       result = Dali::TextureSet::DownCast(arg1);
22020     } catch (std::out_of_range& e) {
22021       {
22022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22023       };
22024     } catch (std::exception& e) {
22025       {
22026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22027       };
22028     } catch (...) {
22029       {
22030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22031       };
22032     }
22033   }
22034   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22035   return jresult;
22036 }
22037
22038
22039 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_Assign(void * jarg1, void * jarg2) {
22040   void * jresult ;
22041   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22042   Dali::TextureSet *arg2 = 0 ;
22043   Dali::TextureSet *result = 0 ;
22044
22045   arg1 = (Dali::TextureSet *)jarg1;
22046   arg2 = (Dali::TextureSet *)jarg2;
22047   if (!arg2) {
22048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22049     return 0;
22050   }
22051   {
22052     try {
22053       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22054     } catch (std::out_of_range& e) {
22055       {
22056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22057       };
22058     } catch (std::exception& e) {
22059       {
22060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22061       };
22062     } catch (...) {
22063       {
22064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22065       };
22066     }
22067   }
22068   jresult = (void *)result;
22069   return jresult;
22070 }
22071
22072
22073 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22074   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22075   size_t arg2 ;
22076   Dali::Texture arg3 ;
22077   Dali::Texture *argp3 ;
22078
22079   arg1 = (Dali::TextureSet *)jarg1;
22080   arg2 = (size_t)jarg2;
22081   argp3 = (Dali::Texture *)jarg3;
22082   if (!argp3) {
22083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22084     return ;
22085   }
22086   arg3 = *argp3;
22087   {
22088     try {
22089       (arg1)->SetTexture(arg2,arg3);
22090     } catch (std::out_of_range& e) {
22091       {
22092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22093       };
22094     } catch (std::exception& e) {
22095       {
22096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22097       };
22098     } catch (...) {
22099       {
22100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22101       };
22102     }
22103   }
22104 }
22105
22106
22107 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22108   void * jresult ;
22109   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22110   size_t arg2 ;
22111   Dali::Texture result;
22112
22113   arg1 = (Dali::TextureSet *)jarg1;
22114   arg2 = (size_t)jarg2;
22115   {
22116     try {
22117       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22118     } catch (std::out_of_range& e) {
22119       {
22120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (std::exception& e) {
22123       {
22124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22125       };
22126     } catch (...) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22129       };
22130     }
22131   }
22132   jresult = new Dali::Texture((const Dali::Texture &)result);
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22138   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22139   size_t arg2 ;
22140   Dali::Sampler arg3 ;
22141   Dali::Sampler *argp3 ;
22142
22143   arg1 = (Dali::TextureSet *)jarg1;
22144   arg2 = (size_t)jarg2;
22145   argp3 = (Dali::Sampler *)jarg3;
22146   if (!argp3) {
22147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22148     return ;
22149   }
22150   arg3 = *argp3;
22151   {
22152     try {
22153       (arg1)->SetSampler(arg2,arg3);
22154     } catch (std::out_of_range& e) {
22155       {
22156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22157       };
22158     } catch (std::exception& e) {
22159       {
22160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (...) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22165       };
22166     }
22167   }
22168 }
22169
22170
22171 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22172   void * jresult ;
22173   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22174   size_t arg2 ;
22175   Dali::Sampler result;
22176
22177   arg1 = (Dali::TextureSet *)jarg1;
22178   arg2 = (size_t)jarg2;
22179   {
22180     try {
22181       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22182     } catch (std::out_of_range& e) {
22183       {
22184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22185       };
22186     } catch (std::exception& e) {
22187       {
22188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22189       };
22190     } catch (...) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22193       };
22194     }
22195   }
22196   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22197   return jresult;
22198 }
22199
22200
22201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextureSet_GetTextureCount(void * jarg1) {
22202   unsigned long jresult ;
22203   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22204   size_t result;
22205
22206   arg1 = (Dali::TextureSet *)jarg1;
22207   {
22208     try {
22209       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22210     } catch (std::out_of_range& e) {
22211       {
22212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22213       };
22214     } catch (std::exception& e) {
22215       {
22216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22217       };
22218     } catch (...) {
22219       {
22220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22221       };
22222     }
22223   }
22224   jresult = (unsigned long)result;
22225   return jresult;
22226 }
22227
22228
22229 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_New(void * jarg1) {
22230   void * jresult ;
22231   Dali::Property::Map *arg1 = 0 ;
22232   Dali::PropertyBuffer result;
22233
22234   arg1 = (Dali::Property::Map *)jarg1;
22235   if (!arg1) {
22236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22237     return 0;
22238   }
22239   {
22240     try {
22241       result = Dali::PropertyBuffer::New(*arg1);
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22249       };
22250     } catch (...) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22253       };
22254     }
22255   }
22256   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22257   return jresult;
22258 }
22259
22260
22261 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyBuffer__SWIG_0() {
22262   void * jresult ;
22263   Dali::PropertyBuffer *result = 0 ;
22264
22265   {
22266     try {
22267       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22268     } catch (std::out_of_range& e) {
22269       {
22270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22271       };
22272     } catch (std::exception& e) {
22273       {
22274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22275       };
22276     } catch (...) {
22277       {
22278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22279       };
22280     }
22281   }
22282   jresult = (void *)result;
22283   return jresult;
22284 }
22285
22286
22287 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyBuffer(void * jarg1) {
22288   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22289
22290   arg1 = (Dali::PropertyBuffer *)jarg1;
22291   {
22292     try {
22293       delete arg1;
22294     } catch (std::out_of_range& e) {
22295       {
22296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22297       };
22298     } catch (std::exception& e) {
22299       {
22300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22301       };
22302     } catch (...) {
22303       {
22304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22305       };
22306     }
22307   }
22308 }
22309
22310
22311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyBuffer__SWIG_1(void * jarg1) {
22312   void * jresult ;
22313   Dali::PropertyBuffer *arg1 = 0 ;
22314   Dali::PropertyBuffer *result = 0 ;
22315
22316   arg1 = (Dali::PropertyBuffer *)jarg1;
22317   if (!arg1) {
22318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22319     return 0;
22320   }
22321   {
22322     try {
22323       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22324     } catch (std::out_of_range& e) {
22325       {
22326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22327       };
22328     } catch (std::exception& e) {
22329       {
22330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22331       };
22332     } catch (...) {
22333       {
22334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22335       };
22336     }
22337   }
22338   jresult = (void *)result;
22339   return jresult;
22340 }
22341
22342
22343 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_DownCast(void * jarg1) {
22344   void * jresult ;
22345   Dali::BaseHandle arg1 ;
22346   Dali::BaseHandle *argp1 ;
22347   Dali::PropertyBuffer result;
22348
22349   argp1 = (Dali::BaseHandle *)jarg1;
22350   if (!argp1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22352     return 0;
22353   }
22354   arg1 = *argp1;
22355   {
22356     try {
22357       result = Dali::PropertyBuffer::DownCast(arg1);
22358     } catch (std::out_of_range& e) {
22359       {
22360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22361       };
22362     } catch (std::exception& e) {
22363       {
22364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22365       };
22366     } catch (...) {
22367       {
22368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22369       };
22370     }
22371   }
22372   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22373   return jresult;
22374 }
22375
22376
22377 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22378   void * jresult ;
22379   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22380   Dali::PropertyBuffer *arg2 = 0 ;
22381   Dali::PropertyBuffer *result = 0 ;
22382
22383   arg1 = (Dali::PropertyBuffer *)jarg1;
22384   arg2 = (Dali::PropertyBuffer *)jarg2;
22385   if (!arg2) {
22386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22387     return 0;
22388   }
22389   {
22390     try {
22391       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22392     } catch (std::out_of_range& e) {
22393       {
22394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22395       };
22396     } catch (std::exception& e) {
22397       {
22398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22399       };
22400     } catch (...) {
22401       {
22402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22403       };
22404     }
22405   }
22406   jresult = (void *)result;
22407   return jresult;
22408 }
22409
22410
22411 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22412   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22413   void *arg2 = (void *) 0 ;
22414   std::size_t arg3 ;
22415
22416   arg1 = (Dali::PropertyBuffer *)jarg1;
22417   arg2 = jarg2;
22418   arg3 = (std::size_t)jarg3;
22419   {
22420     try {
22421       (arg1)->SetData((void const *)arg2,arg3);
22422     } catch (std::out_of_range& e) {
22423       {
22424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22425       };
22426     } catch (std::exception& e) {
22427       {
22428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22429       };
22430     } catch (...) {
22431       {
22432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22433       };
22434     }
22435   }
22436 }
22437
22438
22439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyBuffer_GetSize(void * jarg1) {
22440   unsigned long jresult ;
22441   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22442   std::size_t result;
22443
22444   arg1 = (Dali::PropertyBuffer *)jarg1;
22445   {
22446     try {
22447       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22448     } catch (std::out_of_range& e) {
22449       {
22450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (std::exception& e) {
22453       {
22454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (...) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22459       };
22460     }
22461   }
22462   jresult = (unsigned long)result;
22463   return jresult;
22464 }
22465
22466
22467 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_New() {
22468   void * jresult ;
22469   Dali::Geometry result;
22470
22471   {
22472     try {
22473       result = Dali::Geometry::New();
22474     } catch (std::out_of_range& e) {
22475       {
22476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22477       };
22478     } catch (std::exception& e) {
22479       {
22480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22481       };
22482     } catch (...) {
22483       {
22484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22485       };
22486     }
22487   }
22488   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22489   return jresult;
22490 }
22491
22492
22493 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Geometry__SWIG_0() {
22494   void * jresult ;
22495   Dali::Geometry *result = 0 ;
22496
22497   {
22498     try {
22499       result = (Dali::Geometry *)new Dali::Geometry();
22500     } catch (std::out_of_range& e) {
22501       {
22502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22503       };
22504     } catch (std::exception& e) {
22505       {
22506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22507       };
22508     } catch (...) {
22509       {
22510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22511       };
22512     }
22513   }
22514   jresult = (void *)result;
22515   return jresult;
22516 }
22517
22518
22519 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Geometry(void * jarg1) {
22520   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22521
22522   arg1 = (Dali::Geometry *)jarg1;
22523   {
22524     try {
22525       delete arg1;
22526     } catch (std::out_of_range& e) {
22527       {
22528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22529       };
22530     } catch (std::exception& e) {
22531       {
22532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22533       };
22534     } catch (...) {
22535       {
22536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22537       };
22538     }
22539   }
22540 }
22541
22542
22543 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Geometry__SWIG_1(void * jarg1) {
22544   void * jresult ;
22545   Dali::Geometry *arg1 = 0 ;
22546   Dali::Geometry *result = 0 ;
22547
22548   arg1 = (Dali::Geometry *)jarg1;
22549   if (!arg1) {
22550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22551     return 0;
22552   }
22553   {
22554     try {
22555       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22556     } catch (std::out_of_range& e) {
22557       {
22558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22559       };
22560     } catch (std::exception& e) {
22561       {
22562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22563       };
22564     } catch (...) {
22565       {
22566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22567       };
22568     }
22569   }
22570   jresult = (void *)result;
22571   return jresult;
22572 }
22573
22574
22575 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_DownCast(void * jarg1) {
22576   void * jresult ;
22577   Dali::BaseHandle arg1 ;
22578   Dali::BaseHandle *argp1 ;
22579   Dali::Geometry result;
22580
22581   argp1 = (Dali::BaseHandle *)jarg1;
22582   if (!argp1) {
22583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22584     return 0;
22585   }
22586   arg1 = *argp1;
22587   {
22588     try {
22589       result = Dali::Geometry::DownCast(arg1);
22590     } catch (std::out_of_range& e) {
22591       {
22592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22593       };
22594     } catch (std::exception& e) {
22595       {
22596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22597       };
22598     } catch (...) {
22599       {
22600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22601       };
22602     }
22603   }
22604   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_Assign(void * jarg1, void * jarg2) {
22610   void * jresult ;
22611   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22612   Dali::Geometry *arg2 = 0 ;
22613   Dali::Geometry *result = 0 ;
22614
22615   arg1 = (Dali::Geometry *)jarg1;
22616   arg2 = (Dali::Geometry *)jarg2;
22617   if (!arg2) {
22618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22619     return 0;
22620   }
22621   {
22622     try {
22623       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22624     } catch (std::out_of_range& e) {
22625       {
22626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22627       };
22628     } catch (std::exception& e) {
22629       {
22630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22631       };
22632     } catch (...) {
22633       {
22634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22635       };
22636     }
22637   }
22638   jresult = (void *)result;
22639   return jresult;
22640 }
22641
22642
22643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22644   unsigned long jresult ;
22645   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22646   Dali::PropertyBuffer *arg2 = 0 ;
22647   std::size_t result;
22648
22649   arg1 = (Dali::Geometry *)jarg1;
22650   arg2 = (Dali::PropertyBuffer *)jarg2;
22651   if (!arg2) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22653     return 0;
22654   }
22655   {
22656     try {
22657       result = (arg1)->AddVertexBuffer(*arg2);
22658     } catch (std::out_of_range& e) {
22659       {
22660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22661       };
22662     } catch (std::exception& e) {
22663       {
22664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (...) {
22667       {
22668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22669       };
22670     }
22671   }
22672   jresult = (unsigned long)result;
22673   return jresult;
22674 }
22675
22676
22677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22678   unsigned long jresult ;
22679   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22680   std::size_t result;
22681
22682   arg1 = (Dali::Geometry *)jarg1;
22683   {
22684     try {
22685       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22686     } catch (std::out_of_range& e) {
22687       {
22688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22689       };
22690     } catch (std::exception& e) {
22691       {
22692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22693       };
22694     } catch (...) {
22695       {
22696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22697       };
22698     }
22699   }
22700   jresult = (unsigned long)result;
22701   return jresult;
22702 }
22703
22704
22705 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22706   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22707   std::size_t arg2 ;
22708
22709   arg1 = (Dali::Geometry *)jarg1;
22710   arg2 = (std::size_t)jarg2;
22711   {
22712     try {
22713       (arg1)->RemoveVertexBuffer(arg2);
22714     } catch (std::out_of_range& e) {
22715       {
22716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22717       };
22718     } catch (std::exception& e) {
22719       {
22720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22721       };
22722     } catch (...) {
22723       {
22724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22725       };
22726     }
22727   }
22728 }
22729
22730
22731 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22732   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22733   unsigned short *arg2 = (unsigned short *) 0 ;
22734   size_t arg3 ;
22735
22736   arg1 = (Dali::Geometry *)jarg1;
22737   arg2 = jarg2;
22738   arg3 = (size_t)jarg3;
22739   {
22740     try {
22741       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22742     } catch (std::out_of_range& e) {
22743       {
22744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22745       };
22746     } catch (std::exception& e) {
22747       {
22748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22749       };
22750     } catch (...) {
22751       {
22752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22753       };
22754     }
22755   }
22756
22757
22758 }
22759
22760
22761 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_SetType(void * jarg1, int jarg2) {
22762   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22763   Dali::Geometry::Type arg2 ;
22764
22765   arg1 = (Dali::Geometry *)jarg1;
22766   arg2 = (Dali::Geometry::Type)jarg2;
22767   {
22768     try {
22769       (arg1)->SetType(arg2);
22770     } catch (std::out_of_range& e) {
22771       {
22772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22773       };
22774     } catch (std::exception& e) {
22775       {
22776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22777       };
22778     } catch (...) {
22779       {
22780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22781       };
22782     }
22783   }
22784 }
22785
22786
22787 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Geometry_GetType(void * jarg1) {
22788   int jresult ;
22789   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22790   Dali::Geometry::Type result;
22791
22792   arg1 = (Dali::Geometry *)jarg1;
22793   {
22794     try {
22795       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22796     } catch (std::out_of_range& e) {
22797       {
22798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22799       };
22800     } catch (std::exception& e) {
22801       {
22802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22803       };
22804     } catch (...) {
22805       {
22806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22807       };
22808     }
22809   }
22810   jresult = (int)result;
22811   return jresult;
22812 }
22813
22814
22815 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader_Hint() {
22816   void * jresult ;
22817   Dali::Shader::Hint *result = 0 ;
22818
22819   {
22820     try {
22821       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22829       };
22830     } catch (...) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22833       };
22834     }
22835   }
22836   jresult = (void *)result;
22837   return jresult;
22838 }
22839
22840
22841 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader_Hint(void * jarg1) {
22842   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22843
22844   arg1 = (Dali::Shader::Hint *)jarg1;
22845   {
22846     try {
22847       delete arg1;
22848     } catch (std::out_of_range& e) {
22849       {
22850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22851       };
22852     } catch (std::exception& e) {
22853       {
22854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22855       };
22856     } catch (...) {
22857       {
22858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22859       };
22860     }
22861   }
22862 }
22863
22864
22865 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Shader_Property_PROGRAM_get() {
22866   int jresult ;
22867   int result;
22868
22869   result = (int)Dali::Shader::Property::PROGRAM;
22870   jresult = (int)result;
22871   return jresult;
22872 }
22873
22874
22875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader_Property() {
22876   void * jresult ;
22877   Dali::Shader::Property *result = 0 ;
22878
22879   {
22880     try {
22881       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22882     } catch (std::out_of_range& e) {
22883       {
22884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (std::exception& e) {
22887       {
22888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22889       };
22890     } catch (...) {
22891       {
22892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22893       };
22894     }
22895   }
22896   jresult = (void *)result;
22897   return jresult;
22898 }
22899
22900
22901 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader_Property(void * jarg1) {
22902   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
22903
22904   arg1 = (Dali::Shader::Property *)jarg1;
22905   {
22906     try {
22907       delete arg1;
22908     } catch (std::out_of_range& e) {
22909       {
22910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22911       };
22912     } catch (std::exception& e) {
22913       {
22914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22915       };
22916     } catch (...) {
22917       {
22918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22919       };
22920     }
22921   }
22922 }
22923
22924
22925 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
22926   void * jresult ;
22927   std::string *arg1 = 0 ;
22928   std::string *arg2 = 0 ;
22929   Dali::Shader::Hint::Value arg3 ;
22930   Dali::Shader result;
22931
22932   if (!jarg1) {
22933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22934     return 0;
22935   }
22936   std::string arg1_str(jarg1);
22937   arg1 = &arg1_str;
22938   if (!jarg2) {
22939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22940     return 0;
22941   }
22942   std::string arg2_str(jarg2);
22943   arg2 = &arg2_str;
22944   arg3 = (Dali::Shader::Hint::Value)jarg3;
22945   {
22946     try {
22947       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
22948     } catch (std::out_of_range& e) {
22949       {
22950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22951       };
22952     } catch (std::exception& e) {
22953       {
22954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22955       };
22956     } catch (...) {
22957       {
22958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22959       };
22960     }
22961   }
22962   jresult = new Dali::Shader((const Dali::Shader &)result);
22963
22964   //argout typemap for const std::string&
22965
22966
22967   //argout typemap for const std::string&
22968
22969   return jresult;
22970 }
22971
22972
22973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
22974   void * jresult ;
22975   std::string *arg1 = 0 ;
22976   std::string *arg2 = 0 ;
22977   Dali::Shader result;
22978
22979   if (!jarg1) {
22980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22981     return 0;
22982   }
22983   std::string arg1_str(jarg1);
22984   arg1 = &arg1_str;
22985   if (!jarg2) {
22986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22987     return 0;
22988   }
22989   std::string arg2_str(jarg2);
22990   arg2 = &arg2_str;
22991   {
22992     try {
22993       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
22994     } catch (std::out_of_range& e) {
22995       {
22996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22997       };
22998     } catch (std::exception& e) {
22999       {
23000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23001       };
23002     } catch (...) {
23003       {
23004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23005       };
23006     }
23007   }
23008   jresult = new Dali::Shader((const Dali::Shader &)result);
23009
23010   //argout typemap for const std::string&
23011
23012
23013   //argout typemap for const std::string&
23014
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader__SWIG_0() {
23020   void * jresult ;
23021   Dali::Shader *result = 0 ;
23022
23023   {
23024     try {
23025       result = (Dali::Shader *)new Dali::Shader();
23026     } catch (std::out_of_range& e) {
23027       {
23028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23029       };
23030     } catch (std::exception& e) {
23031       {
23032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23033       };
23034     } catch (...) {
23035       {
23036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23037       };
23038     }
23039   }
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader(void * jarg1) {
23046   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23047
23048   arg1 = (Dali::Shader *)jarg1;
23049   {
23050     try {
23051       delete arg1;
23052     } catch (std::out_of_range& e) {
23053       {
23054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23055       };
23056     } catch (std::exception& e) {
23057       {
23058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23059       };
23060     } catch (...) {
23061       {
23062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23063       };
23064     }
23065   }
23066 }
23067
23068
23069 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader__SWIG_1(void * jarg1) {
23070   void * jresult ;
23071   Dali::Shader *arg1 = 0 ;
23072   Dali::Shader *result = 0 ;
23073
23074   arg1 = (Dali::Shader *)jarg1;
23075   if (!arg1) {
23076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23077     return 0;
23078   }
23079   {
23080     try {
23081       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23082     } catch (std::out_of_range& e) {
23083       {
23084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23085       };
23086     } catch (std::exception& e) {
23087       {
23088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23089       };
23090     } catch (...) {
23091       {
23092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23093       };
23094     }
23095   }
23096   jresult = (void *)result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_DownCast(void * jarg1) {
23102   void * jresult ;
23103   Dali::BaseHandle arg1 ;
23104   Dali::BaseHandle *argp1 ;
23105   Dali::Shader result;
23106
23107   argp1 = (Dali::BaseHandle *)jarg1;
23108   if (!argp1) {
23109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23110     return 0;
23111   }
23112   arg1 = *argp1;
23113   {
23114     try {
23115       result = Dali::Shader::DownCast(arg1);
23116     } catch (std::out_of_range& e) {
23117       {
23118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23119       };
23120     } catch (std::exception& e) {
23121       {
23122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23123       };
23124     } catch (...) {
23125       {
23126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23127       };
23128     }
23129   }
23130   jresult = new Dali::Shader((const Dali::Shader &)result);
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_Assign(void * jarg1, void * jarg2) {
23136   void * jresult ;
23137   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23138   Dali::Shader *arg2 = 0 ;
23139   Dali::Shader *result = 0 ;
23140
23141   arg1 = (Dali::Shader *)jarg1;
23142   arg2 = (Dali::Shader *)jarg2;
23143   if (!arg2) {
23144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23145     return 0;
23146   }
23147   {
23148     try {
23149       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23150     } catch (std::out_of_range& e) {
23151       {
23152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23153       };
23154     } catch (std::exception& e) {
23155       {
23156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23157       };
23158     } catch (...) {
23159       {
23160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23161       };
23162     }
23163   }
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_INDEX_get() {
23170   int jresult ;
23171   int result;
23172
23173   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23174   jresult = (int)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_FACE_CULLING_MODE_get() {
23180   int jresult ;
23181   int result;
23182
23183   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23184   jresult = (int)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_MODE_get() {
23190   int jresult ;
23191   int result;
23192
23193   result = (int)Dali::Renderer::Property::BLEND_MODE;
23194   jresult = (int)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_EQUATION_RGB_get() {
23200   int jresult ;
23201   int result;
23202
23203   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23204   jresult = (int)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23210   int jresult ;
23211   int result;
23212
23213   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23214   jresult = (int)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23220   int jresult ;
23221   int result;
23222
23223   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23224   jresult = (int)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23230   int jresult ;
23231   int result;
23232
23233   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23234   jresult = (int)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23240   int jresult ;
23241   int result;
23242
23243   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23244   jresult = (int)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23250   int jresult ;
23251   int result;
23252
23253   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23254   jresult = (int)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_COLOR_get() {
23260   int jresult ;
23261   int result;
23262
23263   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23264   jresult = (int)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23270   int jresult ;
23271   int result;
23272
23273   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23274   jresult = (int)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_INDEX_RANGE_FIRST_get() {
23280   int jresult ;
23281   int result;
23282
23283   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23284   jresult = (int)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_INDEX_RANGE_COUNT_get() {
23290   int jresult ;
23291   int result;
23292
23293   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23294   jresult = (int)result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_WRITE_MODE_get() {
23300   int jresult ;
23301   int result;
23302
23303   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23304   jresult = (int)result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_FUNCTION_get() {
23310   int jresult ;
23311   int result;
23312
23313   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23314   jresult = (int)result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_TEST_MODE_get() {
23320   int jresult ;
23321   int result;
23322
23323   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23324   jresult = (int)result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_RENDER_MODE_get() {
23330   int jresult ;
23331   int result;
23332
23333   result = (int)Dali::Renderer::Property::RENDER_MODE;
23334   jresult = (int)result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_get() {
23340   int jresult ;
23341   int result;
23342
23343   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23344   jresult = (int)result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23350   int jresult ;
23351   int result;
23352
23353   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23354   jresult = (int)result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23360   int jresult ;
23361   int result;
23362
23363   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23364   jresult = (int)result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_MASK_get() {
23370   int jresult ;
23371   int result;
23372
23373   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23374   jresult = (int)result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23380   int jresult ;
23381   int result;
23382
23383   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23384   jresult = (int)result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23390   int jresult ;
23391   int result;
23392
23393   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23400   int jresult ;
23401   int result;
23402
23403   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23404   jresult = (int)result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer_Property() {
23410   void * jresult ;
23411   Dali::Renderer::Property *result = 0 ;
23412
23413   {
23414     try {
23415       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23416     } catch (std::out_of_range& e) {
23417       {
23418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23419       };
23420     } catch (std::exception& e) {
23421       {
23422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23423       };
23424     } catch (...) {
23425       {
23426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23427       };
23428     }
23429   }
23430   jresult = (void *)result;
23431   return jresult;
23432 }
23433
23434
23435 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Renderer_Property(void * jarg1) {
23436   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23437
23438   arg1 = (Dali::Renderer::Property *)jarg1;
23439   {
23440     try {
23441       delete arg1;
23442     } catch (std::out_of_range& e) {
23443       {
23444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23445       };
23446     } catch (std::exception& e) {
23447       {
23448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23449       };
23450     } catch (...) {
23451       {
23452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23453       };
23454     }
23455   }
23456 }
23457
23458
23459 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_New(void * jarg1, void * jarg2) {
23460   void * jresult ;
23461   Dali::Geometry *arg1 = 0 ;
23462   Dali::Shader *arg2 = 0 ;
23463   Dali::Renderer result;
23464
23465   arg1 = (Dali::Geometry *)jarg1;
23466   if (!arg1) {
23467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23468     return 0;
23469   }
23470   arg2 = (Dali::Shader *)jarg2;
23471   if (!arg2) {
23472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23473     return 0;
23474   }
23475   {
23476     try {
23477       result = Dali::Renderer::New(*arg1,*arg2);
23478     } catch (std::out_of_range& e) {
23479       {
23480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23481       };
23482     } catch (std::exception& e) {
23483       {
23484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23485       };
23486     } catch (...) {
23487       {
23488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23489       };
23490     }
23491   }
23492   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer__SWIG_0() {
23498   void * jresult ;
23499   Dali::Renderer *result = 0 ;
23500
23501   {
23502     try {
23503       result = (Dali::Renderer *)new Dali::Renderer();
23504     } catch (std::out_of_range& e) {
23505       {
23506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23507       };
23508     } catch (std::exception& e) {
23509       {
23510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23511       };
23512     } catch (...) {
23513       {
23514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23515       };
23516     }
23517   }
23518   jresult = (void *)result;
23519   return jresult;
23520 }
23521
23522
23523 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Renderer(void * jarg1) {
23524   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23525
23526   arg1 = (Dali::Renderer *)jarg1;
23527   {
23528     try {
23529       delete arg1;
23530     } catch (std::out_of_range& e) {
23531       {
23532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23533       };
23534     } catch (std::exception& e) {
23535       {
23536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23537       };
23538     } catch (...) {
23539       {
23540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23541       };
23542     }
23543   }
23544 }
23545
23546
23547 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer__SWIG_1(void * jarg1) {
23548   void * jresult ;
23549   Dali::Renderer *arg1 = 0 ;
23550   Dali::Renderer *result = 0 ;
23551
23552   arg1 = (Dali::Renderer *)jarg1;
23553   if (!arg1) {
23554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23555     return 0;
23556   }
23557   {
23558     try {
23559       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23560     } catch (std::out_of_range& e) {
23561       {
23562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23563       };
23564     } catch (std::exception& e) {
23565       {
23566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (...) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23571       };
23572     }
23573   }
23574   jresult = (void *)result;
23575   return jresult;
23576 }
23577
23578
23579 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_DownCast(void * jarg1) {
23580   void * jresult ;
23581   Dali::BaseHandle arg1 ;
23582   Dali::BaseHandle *argp1 ;
23583   Dali::Renderer result;
23584
23585   argp1 = (Dali::BaseHandle *)jarg1;
23586   if (!argp1) {
23587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23588     return 0;
23589   }
23590   arg1 = *argp1;
23591   {
23592     try {
23593       result = Dali::Renderer::DownCast(arg1);
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23601       };
23602     } catch (...) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23605       };
23606     }
23607   }
23608   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23609   return jresult;
23610 }
23611
23612
23613 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_Assign(void * jarg1, void * jarg2) {
23614   void * jresult ;
23615   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23616   Dali::Renderer *arg2 = 0 ;
23617   Dali::Renderer *result = 0 ;
23618
23619   arg1 = (Dali::Renderer *)jarg1;
23620   arg2 = (Dali::Renderer *)jarg2;
23621   if (!arg2) {
23622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23623     return 0;
23624   }
23625   {
23626     try {
23627       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23628     } catch (std::out_of_range& e) {
23629       {
23630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23631       };
23632     } catch (std::exception& e) {
23633       {
23634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (...) {
23637       {
23638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23639       };
23640     }
23641   }
23642   jresult = (void *)result;
23643   return jresult;
23644 }
23645
23646
23647 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23648   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23649   Dali::Geometry *arg2 = 0 ;
23650
23651   arg1 = (Dali::Renderer *)jarg1;
23652   arg2 = (Dali::Geometry *)jarg2;
23653   if (!arg2) {
23654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23655     return ;
23656   }
23657   {
23658     try {
23659       (arg1)->SetGeometry(*arg2);
23660     } catch (std::out_of_range& e) {
23661       {
23662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23663       };
23664     } catch (std::exception& e) {
23665       {
23666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23667       };
23668     } catch (...) {
23669       {
23670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23671       };
23672     }
23673   }
23674 }
23675
23676
23677 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetGeometry(void * jarg1) {
23678   void * jresult ;
23679   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23680   Dali::Geometry result;
23681
23682   arg1 = (Dali::Renderer *)jarg1;
23683   {
23684     try {
23685       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23686     } catch (std::out_of_range& e) {
23687       {
23688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23689       };
23690     } catch (std::exception& e) {
23691       {
23692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23693       };
23694     } catch (...) {
23695       {
23696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23697       };
23698     }
23699   }
23700   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23701   return jresult;
23702 }
23703
23704
23705 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23706   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23707   int arg2 ;
23708   int arg3 ;
23709
23710   arg1 = (Dali::Renderer *)jarg1;
23711   arg2 = (int)jarg2;
23712   arg3 = (int)jarg3;
23713   {
23714     try {
23715       (arg1)->SetIndexRange(arg2,arg3);
23716     } catch (std::out_of_range& e) {
23717       {
23718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23719       };
23720     } catch (std::exception& e) {
23721       {
23722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23723       };
23724     } catch (...) {
23725       {
23726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23727       };
23728     }
23729   }
23730 }
23731
23732
23733 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetTextures(void * jarg1, void * jarg2) {
23734   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23735   Dali::TextureSet *arg2 = 0 ;
23736
23737   arg1 = (Dali::Renderer *)jarg1;
23738   arg2 = (Dali::TextureSet *)jarg2;
23739   if (!arg2) {
23740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23741     return ;
23742   }
23743   {
23744     try {
23745       (arg1)->SetTextures(*arg2);
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23753       };
23754     } catch (...) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23757       };
23758     }
23759   }
23760 }
23761
23762
23763 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetTextures(void * jarg1) {
23764   void * jresult ;
23765   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23766   Dali::TextureSet result;
23767
23768   arg1 = (Dali::Renderer *)jarg1;
23769   {
23770     try {
23771       result = ((Dali::Renderer const *)arg1)->GetTextures();
23772     } catch (std::out_of_range& e) {
23773       {
23774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23775       };
23776     } catch (std::exception& e) {
23777       {
23778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23779       };
23780     } catch (...) {
23781       {
23782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23783       };
23784     }
23785   }
23786   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23787   return jresult;
23788 }
23789
23790
23791 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetShader(void * jarg1, void * jarg2) {
23792   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23793   Dali::Shader *arg2 = 0 ;
23794
23795   arg1 = (Dali::Renderer *)jarg1;
23796   arg2 = (Dali::Shader *)jarg2;
23797   if (!arg2) {
23798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23799     return ;
23800   }
23801   {
23802     try {
23803       (arg1)->SetShader(*arg2);
23804     } catch (std::out_of_range& e) {
23805       {
23806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23807       };
23808     } catch (std::exception& e) {
23809       {
23810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23811       };
23812     } catch (...) {
23813       {
23814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23815       };
23816     }
23817   }
23818 }
23819
23820
23821 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetShader(void * jarg1) {
23822   void * jresult ;
23823   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23824   Dali::Shader result;
23825
23826   arg1 = (Dali::Renderer *)jarg1;
23827   {
23828     try {
23829       result = ((Dali::Renderer const *)arg1)->GetShader();
23830     } catch (std::out_of_range& e) {
23831       {
23832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23833       };
23834     } catch (std::exception& e) {
23835       {
23836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23837       };
23838     } catch (...) {
23839       {
23840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23841       };
23842     }
23843   }
23844   jresult = new Dali::Shader((const Dali::Shader &)result);
23845   return jresult;
23846 }
23847
23848
23849 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer_Attachment() {
23850   void * jresult ;
23851   Dali::FrameBuffer::Attachment *result = 0 ;
23852
23853   {
23854     try {
23855       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23856     } catch (std::out_of_range& e) {
23857       {
23858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23859       };
23860     } catch (std::exception& e) {
23861       {
23862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23863       };
23864     } catch (...) {
23865       {
23866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23867       };
23868     }
23869   }
23870   jresult = (void *)result;
23871   return jresult;
23872 }
23873
23874
23875 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBuffer_Attachment(void * jarg1) {
23876   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23877
23878   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23879   {
23880     try {
23881       delete arg1;
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23889       };
23890     } catch (...) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23893       };
23894     }
23895   }
23896 }
23897
23898
23899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
23900   void * jresult ;
23901   unsigned int arg1 ;
23902   unsigned int arg2 ;
23903   unsigned int arg3 ;
23904   Dali::FrameBuffer result;
23905
23906   arg1 = (unsigned int)jarg1;
23907   arg2 = (unsigned int)jarg2;
23908   arg3 = (unsigned int)jarg3;
23909   {
23910     try {
23911       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
23912     } catch (std::out_of_range& e) {
23913       {
23914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23915       };
23916     } catch (std::exception& e) {
23917       {
23918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23919       };
23920     } catch (...) {
23921       {
23922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23923       };
23924     }
23925   }
23926   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
23927   return jresult;
23928 }
23929
23930
23931 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer__SWIG_0() {
23932   void * jresult ;
23933   Dali::FrameBuffer *result = 0 ;
23934
23935   {
23936     try {
23937       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23945       };
23946     } catch (...) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23949       };
23950     }
23951   }
23952   jresult = (void *)result;
23953   return jresult;
23954 }
23955
23956
23957 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBuffer(void * jarg1) {
23958   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
23959
23960   arg1 = (Dali::FrameBuffer *)jarg1;
23961   {
23962     try {
23963       delete arg1;
23964     } catch (std::out_of_range& e) {
23965       {
23966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23967       };
23968     } catch (std::exception& e) {
23969       {
23970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23971       };
23972     } catch (...) {
23973       {
23974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23975       };
23976     }
23977   }
23978 }
23979
23980
23981 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer__SWIG_1(void * jarg1) {
23982   void * jresult ;
23983   Dali::FrameBuffer *arg1 = 0 ;
23984   Dali::FrameBuffer *result = 0 ;
23985
23986   arg1 = (Dali::FrameBuffer *)jarg1;
23987   if (!arg1) {
23988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
23989     return 0;
23990   }
23991   {
23992     try {
23993       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
23994     } catch (std::out_of_range& e) {
23995       {
23996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23997       };
23998     } catch (std::exception& e) {
23999       {
24000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24001       };
24002     } catch (...) {
24003       {
24004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24005       };
24006     }
24007   }
24008   jresult = (void *)result;
24009   return jresult;
24010 }
24011
24012
24013 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_DownCast(void * jarg1) {
24014   void * jresult ;
24015   Dali::BaseHandle arg1 ;
24016   Dali::BaseHandle *argp1 ;
24017   Dali::FrameBuffer result;
24018
24019   argp1 = (Dali::BaseHandle *)jarg1;
24020   if (!argp1) {
24021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24022     return 0;
24023   }
24024   arg1 = *argp1;
24025   {
24026     try {
24027       result = Dali::FrameBuffer::DownCast(arg1);
24028     } catch (std::out_of_range& e) {
24029       {
24030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24031       };
24032     } catch (std::exception& e) {
24033       {
24034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24035       };
24036     } catch (...) {
24037       {
24038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24039       };
24040     }
24041   }
24042   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24043   return jresult;
24044 }
24045
24046
24047 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24048   void * jresult ;
24049   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24050   Dali::FrameBuffer *arg2 = 0 ;
24051   Dali::FrameBuffer *result = 0 ;
24052
24053   arg1 = (Dali::FrameBuffer *)jarg1;
24054   arg2 = (Dali::FrameBuffer *)jarg2;
24055   if (!arg2) {
24056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24057     return 0;
24058   }
24059   {
24060     try {
24061       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24062     } catch (std::out_of_range& e) {
24063       {
24064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24065       };
24066     } catch (std::exception& e) {
24067       {
24068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (...) {
24071       {
24072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24073       };
24074     }
24075   }
24076   jresult = (void *)result;
24077   return jresult;
24078 }
24079
24080
24081 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24082   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24083   Dali::Texture *arg2 = 0 ;
24084
24085   arg1 = (Dali::FrameBuffer *)jarg1;
24086   arg2 = (Dali::Texture *)jarg2;
24087   if (!arg2) {
24088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24089     return ;
24090   }
24091   {
24092     try {
24093       (arg1)->AttachColorTexture(*arg2);
24094     } catch (std::out_of_range& e) {
24095       {
24096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24097       };
24098     } catch (std::exception& e) {
24099       {
24100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24101       };
24102     } catch (...) {
24103       {
24104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24105       };
24106     }
24107   }
24108 }
24109
24110
24111 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24112   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24113   Dali::Texture *arg2 = 0 ;
24114   unsigned int arg3 ;
24115   unsigned int arg4 ;
24116
24117   arg1 = (Dali::FrameBuffer *)jarg1;
24118   arg2 = (Dali::Texture *)jarg2;
24119   if (!arg2) {
24120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24121     return ;
24122   }
24123   arg3 = (unsigned int)jarg3;
24124   arg4 = (unsigned int)jarg4;
24125   {
24126     try {
24127       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24128     } catch (std::out_of_range& e) {
24129       {
24130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24131       };
24132     } catch (std::exception& e) {
24133       {
24134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24135       };
24136     } catch (...) {
24137       {
24138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24139       };
24140     }
24141   }
24142 }
24143
24144
24145 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_GetColorTexture(void * jarg1) {
24146   void * jresult ;
24147   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24148   Dali::Texture result;
24149
24150   arg1 = (Dali::FrameBuffer *)jarg1;
24151   {
24152     try {
24153       result = (arg1)->GetColorTexture();
24154     } catch (std::out_of_range& e) {
24155       {
24156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24157       };
24158     } catch (std::exception& e) {
24159       {
24160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24161       };
24162     } catch (...) {
24163       {
24164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24165       };
24166     }
24167   }
24168   jresult = new Dali::Texture((const Dali::Texture &)result);
24169   return jresult;
24170 }
24171
24172
24173 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskList__SWIG_0() {
24174   void * jresult ;
24175   Dali::RenderTaskList *result = 0 ;
24176
24177   {
24178     try {
24179       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24180     } catch (std::out_of_range& e) {
24181       {
24182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24183       };
24184     } catch (std::exception& e) {
24185       {
24186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (...) {
24189       {
24190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24191       };
24192     }
24193   }
24194   jresult = (void *)result;
24195   return jresult;
24196 }
24197
24198
24199 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_DownCast(void * jarg1) {
24200   void * jresult ;
24201   Dali::BaseHandle arg1 ;
24202   Dali::BaseHandle *argp1 ;
24203   Dali::RenderTaskList result;
24204
24205   argp1 = (Dali::BaseHandle *)jarg1;
24206   if (!argp1) {
24207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24208     return 0;
24209   }
24210   arg1 = *argp1;
24211   {
24212     try {
24213       result = Dali::RenderTaskList::DownCast(arg1);
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (...) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24225       };
24226     }
24227   }
24228   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24229   return jresult;
24230 }
24231
24232
24233 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTaskList(void * jarg1) {
24234   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24235
24236   arg1 = (Dali::RenderTaskList *)jarg1;
24237   {
24238     try {
24239       delete arg1;
24240     } catch (std::out_of_range& e) {
24241       {
24242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24243       };
24244     } catch (std::exception& e) {
24245       {
24246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24247       };
24248     } catch (...) {
24249       {
24250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24251       };
24252     }
24253   }
24254 }
24255
24256
24257 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskList__SWIG_1(void * jarg1) {
24258   void * jresult ;
24259   Dali::RenderTaskList *arg1 = 0 ;
24260   Dali::RenderTaskList *result = 0 ;
24261
24262   arg1 = (Dali::RenderTaskList *)jarg1;
24263   if (!arg1) {
24264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24265     return 0;
24266   }
24267   {
24268     try {
24269       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24270     } catch (std::out_of_range& e) {
24271       {
24272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24273       };
24274     } catch (std::exception& e) {
24275       {
24276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24277       };
24278     } catch (...) {
24279       {
24280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24281       };
24282     }
24283   }
24284   jresult = (void *)result;
24285   return jresult;
24286 }
24287
24288
24289 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24290   void * jresult ;
24291   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24292   Dali::RenderTaskList *arg2 = 0 ;
24293   Dali::RenderTaskList *result = 0 ;
24294
24295   arg1 = (Dali::RenderTaskList *)jarg1;
24296   arg2 = (Dali::RenderTaskList *)jarg2;
24297   if (!arg2) {
24298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24299     return 0;
24300   }
24301   {
24302     try {
24303       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24304     } catch (std::out_of_range& e) {
24305       {
24306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24307       };
24308     } catch (std::exception& e) {
24309       {
24310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24311       };
24312     } catch (...) {
24313       {
24314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24315       };
24316     }
24317   }
24318   jresult = (void *)result;
24319   return jresult;
24320 }
24321
24322
24323 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_CreateTask(void * jarg1) {
24324   void * jresult ;
24325   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24326   Dali::RenderTask result;
24327
24328   arg1 = (Dali::RenderTaskList *)jarg1;
24329   {
24330     try {
24331       result = (arg1)->CreateTask();
24332     } catch (std::out_of_range& e) {
24333       {
24334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24335       };
24336     } catch (std::exception& e) {
24337       {
24338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24339       };
24340     } catch (...) {
24341       {
24342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24343       };
24344     }
24345   }
24346   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24347   return jresult;
24348 }
24349
24350
24351 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24352   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24353   Dali::RenderTask arg2 ;
24354   Dali::RenderTask *argp2 ;
24355
24356   arg1 = (Dali::RenderTaskList *)jarg1;
24357   argp2 = (Dali::RenderTask *)jarg2;
24358   if (!argp2) {
24359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24360     return ;
24361   }
24362   arg2 = *argp2;
24363   {
24364     try {
24365       (arg1)->RemoveTask(arg2);
24366     } catch (std::out_of_range& e) {
24367       {
24368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24369       };
24370     } catch (std::exception& e) {
24371       {
24372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24373       };
24374     } catch (...) {
24375       {
24376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24377       };
24378     }
24379   }
24380 }
24381
24382
24383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTaskList_GetTaskCount(void * jarg1) {
24384   unsigned int jresult ;
24385   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24386   unsigned int result;
24387
24388   arg1 = (Dali::RenderTaskList *)jarg1;
24389   {
24390     try {
24391       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24392     } catch (std::out_of_range& e) {
24393       {
24394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (std::exception& e) {
24397       {
24398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24399       };
24400     } catch (...) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24403       };
24404     }
24405   }
24406   jresult = result;
24407   return jresult;
24408 }
24409
24410
24411 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24412   void * jresult ;
24413   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24414   unsigned int arg2 ;
24415   Dali::RenderTask result;
24416
24417   arg1 = (Dali::RenderTaskList *)jarg1;
24418   arg2 = (unsigned int)jarg2;
24419   {
24420     try {
24421       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24422     } catch (std::out_of_range& e) {
24423       {
24424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24425       };
24426     } catch (std::exception& e) {
24427       {
24428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24429       };
24430     } catch (...) {
24431       {
24432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24433       };
24434     }
24435   }
24436   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24437   return jresult;
24438 }
24439
24440
24441 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_VIEWPORT_POSITION_get() {
24442   int jresult ;
24443   int result;
24444
24445   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24446   jresult = (int)result;
24447   return jresult;
24448 }
24449
24450
24451 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_VIEWPORT_SIZE_get() {
24452   int jresult ;
24453   int result;
24454
24455   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24456   jresult = (int)result;
24457   return jresult;
24458 }
24459
24460
24461 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_CLEAR_COLOR_get() {
24462   int jresult ;
24463   int result;
24464
24465   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24466   jresult = (int)result;
24467   return jresult;
24468 }
24469
24470
24471 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_REQUIRES_SYNC_get() {
24472   int jresult ;
24473   int result;
24474
24475   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24476   jresult = (int)result;
24477   return jresult;
24478 }
24479
24480
24481 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask_Property() {
24482   void * jresult ;
24483   Dali::RenderTask::Property *result = 0 ;
24484
24485   {
24486     try {
24487       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24488     } catch (std::out_of_range& e) {
24489       {
24490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24491       };
24492     } catch (std::exception& e) {
24493       {
24494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (...) {
24497       {
24498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24499       };
24500     }
24501   }
24502   jresult = (void *)result;
24503   return jresult;
24504 }
24505
24506
24507 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTask_Property(void * jarg1) {
24508   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24509
24510   arg1 = (Dali::RenderTask::Property *)jarg1;
24511   {
24512     try {
24513       delete arg1;
24514     } catch (std::out_of_range& e) {
24515       {
24516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24517       };
24518     } catch (std::exception& e) {
24519       {
24520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24521       };
24522     } catch (...) {
24523       {
24524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24525       };
24526     }
24527   }
24528 }
24529
24530
24531 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24532   void * jresult ;
24533   bool (*result)(Dali::Vector2 &) = 0 ;
24534
24535   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24536   jresult = (void *)result;
24537   return jresult;
24538 }
24539
24540
24541 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24542   void * jresult ;
24543   bool (*result)(Dali::Vector2 &) = 0 ;
24544
24545   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24546   jresult = (void *)result;
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_EXCLUSIVE_get() {
24552   unsigned int jresult ;
24553   bool result;
24554
24555   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24556   jresult = result;
24557   return jresult;
24558 }
24559
24560
24561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24562   unsigned int jresult ;
24563   bool result;
24564
24565   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24566   jresult = result;
24567   return jresult;
24568 }
24569
24570
24571 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24572   void * jresult ;
24573   Dali::Vector4 *result = 0 ;
24574
24575   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24576   jresult = (void *)result;
24577   return jresult;
24578 }
24579
24580
24581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24582   unsigned int jresult ;
24583   bool result;
24584
24585   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24586   jresult = result;
24587   return jresult;
24588 }
24589
24590
24591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CULL_MODE_get() {
24592   unsigned int jresult ;
24593   bool result;
24594
24595   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24596   jresult = result;
24597   return jresult;
24598 }
24599
24600
24601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_REFRESH_RATE_get() {
24602   unsigned int jresult ;
24603   unsigned int result;
24604
24605   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24606   jresult = result;
24607   return jresult;
24608 }
24609
24610
24611 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask__SWIG_0() {
24612   void * jresult ;
24613   Dali::RenderTask *result = 0 ;
24614
24615   {
24616     try {
24617       result = (Dali::RenderTask *)new Dali::RenderTask();
24618     } catch (std::out_of_range& e) {
24619       {
24620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24621       };
24622     } catch (std::exception& e) {
24623       {
24624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (...) {
24627       {
24628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24629       };
24630     }
24631   }
24632   jresult = (void *)result;
24633   return jresult;
24634 }
24635
24636
24637 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DownCast(void * jarg1) {
24638   void * jresult ;
24639   Dali::BaseHandle arg1 ;
24640   Dali::BaseHandle *argp1 ;
24641   Dali::RenderTask result;
24642
24643   argp1 = (Dali::BaseHandle *)jarg1;
24644   if (!argp1) {
24645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24646     return 0;
24647   }
24648   arg1 = *argp1;
24649   {
24650     try {
24651       result = Dali::RenderTask::DownCast(arg1);
24652     } catch (std::out_of_range& e) {
24653       {
24654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24655       };
24656     } catch (std::exception& e) {
24657       {
24658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24659       };
24660     } catch (...) {
24661       {
24662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24663       };
24664     }
24665   }
24666   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24667   return jresult;
24668 }
24669
24670
24671 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTask(void * jarg1) {
24672   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24673
24674   arg1 = (Dali::RenderTask *)jarg1;
24675   {
24676     try {
24677       delete arg1;
24678     } catch (std::out_of_range& e) {
24679       {
24680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24681       };
24682     } catch (std::exception& e) {
24683       {
24684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24685       };
24686     } catch (...) {
24687       {
24688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24689       };
24690     }
24691   }
24692 }
24693
24694
24695 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask__SWIG_1(void * jarg1) {
24696   void * jresult ;
24697   Dali::RenderTask *arg1 = 0 ;
24698   Dali::RenderTask *result = 0 ;
24699
24700   arg1 = (Dali::RenderTask *)jarg1;
24701   if (!arg1) {
24702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24703     return 0;
24704   }
24705   {
24706     try {
24707       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24708     } catch (std::out_of_range& e) {
24709       {
24710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24711       };
24712     } catch (std::exception& e) {
24713       {
24714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24719       };
24720     }
24721   }
24722   jresult = (void *)result;
24723   return jresult;
24724 }
24725
24726
24727 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_Assign(void * jarg1, void * jarg2) {
24728   void * jresult ;
24729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24730   Dali::RenderTask *arg2 = 0 ;
24731   Dali::RenderTask *result = 0 ;
24732
24733   arg1 = (Dali::RenderTask *)jarg1;
24734   arg2 = (Dali::RenderTask *)jarg2;
24735   if (!arg2) {
24736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24737     return 0;
24738   }
24739   {
24740     try {
24741       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24742     } catch (std::out_of_range& e) {
24743       {
24744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24745       };
24746     } catch (std::exception& e) {
24747       {
24748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24749       };
24750     } catch (...) {
24751       {
24752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24753       };
24754     }
24755   }
24756   jresult = (void *)result;
24757   return jresult;
24758 }
24759
24760
24761 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24762   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24763   Dali::Actor arg2 ;
24764   Dali::Actor *argp2 ;
24765
24766   arg1 = (Dali::RenderTask *)jarg1;
24767   argp2 = (Dali::Actor *)jarg2;
24768   if (!argp2) {
24769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24770     return ;
24771   }
24772   arg2 = *argp2;
24773   {
24774     try {
24775       (arg1)->SetSourceActor(arg2);
24776     } catch (std::out_of_range& e) {
24777       {
24778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24779       };
24780     } catch (std::exception& e) {
24781       {
24782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24783       };
24784     } catch (...) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24787       };
24788     }
24789   }
24790 }
24791
24792
24793 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetSourceActor(void * jarg1) {
24794   void * jresult ;
24795   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24796   Dali::Actor result;
24797
24798   arg1 = (Dali::RenderTask *)jarg1;
24799   {
24800     try {
24801       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24802     } catch (std::out_of_range& e) {
24803       {
24804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24805       };
24806     } catch (std::exception& e) {
24807       {
24808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24809       };
24810     } catch (...) {
24811       {
24812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24813       };
24814     }
24815   }
24816   jresult = new Dali::Actor((const Dali::Actor &)result);
24817   return jresult;
24818 }
24819
24820
24821 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24822   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24823   bool arg2 ;
24824
24825   arg1 = (Dali::RenderTask *)jarg1;
24826   arg2 = jarg2 ? true : false;
24827   {
24828     try {
24829       (arg1)->SetExclusive(arg2);
24830     } catch (std::out_of_range& e) {
24831       {
24832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24833       };
24834     } catch (std::exception& e) {
24835       {
24836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24837       };
24838     } catch (...) {
24839       {
24840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24841       };
24842     }
24843   }
24844 }
24845
24846
24847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_IsExclusive(void * jarg1) {
24848   unsigned int jresult ;
24849   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24850   bool result;
24851
24852   arg1 = (Dali::RenderTask *)jarg1;
24853   {
24854     try {
24855       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24856     } catch (std::out_of_range& e) {
24857       {
24858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24859       };
24860     } catch (std::exception& e) {
24861       {
24862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24863       };
24864     } catch (...) {
24865       {
24866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24867       };
24868     }
24869   }
24870   jresult = result;
24871   return jresult;
24872 }
24873
24874
24875 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24876   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24877   bool arg2 ;
24878
24879   arg1 = (Dali::RenderTask *)jarg1;
24880   arg2 = jarg2 ? true : false;
24881   {
24882     try {
24883       (arg1)->SetInputEnabled(arg2);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24891       };
24892     } catch (...) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24895       };
24896     }
24897   }
24898 }
24899
24900
24901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetInputEnabled(void * jarg1) {
24902   unsigned int jresult ;
24903   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24904   bool result;
24905
24906   arg1 = (Dali::RenderTask *)jarg1;
24907   {
24908     try {
24909       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
24910     } catch (std::out_of_range& e) {
24911       {
24912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24913       };
24914     } catch (std::exception& e) {
24915       {
24916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24917       };
24918     } catch (...) {
24919       {
24920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24921       };
24922     }
24923   }
24924   jresult = result;
24925   return jresult;
24926 }
24927
24928
24929 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
24930   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24931   Dali::CameraActor arg2 ;
24932   Dali::CameraActor *argp2 ;
24933
24934   arg1 = (Dali::RenderTask *)jarg1;
24935   argp2 = (Dali::CameraActor *)jarg2;
24936   if (!argp2) {
24937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
24938     return ;
24939   }
24940   arg2 = *argp2;
24941   {
24942     try {
24943       (arg1)->SetCameraActor(arg2);
24944     } catch (std::out_of_range& e) {
24945       {
24946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24947       };
24948     } catch (std::exception& e) {
24949       {
24950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24951       };
24952     } catch (...) {
24953       {
24954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24955       };
24956     }
24957   }
24958 }
24959
24960
24961 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCameraActor(void * jarg1) {
24962   void * jresult ;
24963   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24964   Dali::CameraActor result;
24965
24966   arg1 = (Dali::RenderTask *)jarg1;
24967   {
24968     try {
24969       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
24970     } catch (std::out_of_range& e) {
24971       {
24972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24973       };
24974     } catch (std::exception& e) {
24975       {
24976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24977       };
24978     } catch (...) {
24979       {
24980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24981       };
24982     }
24983   }
24984   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
24985   return jresult;
24986 }
24987
24988
24989 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
24990   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24991   Dali::FrameBufferImage arg2 ;
24992   Dali::FrameBufferImage *argp2 ;
24993
24994   arg1 = (Dali::RenderTask *)jarg1;
24995   argp2 = (Dali::FrameBufferImage *)jarg2;
24996   if (!argp2) {
24997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
24998     return ;
24999   }
25000   arg2 = *argp2;
25001   {
25002     try {
25003       (arg1)->SetTargetFrameBuffer(arg2);
25004     } catch (std::out_of_range& e) {
25005       {
25006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25007       };
25008     } catch (std::exception& e) {
25009       {
25010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25011       };
25012     } catch (...) {
25013       {
25014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25015       };
25016     }
25017   }
25018 }
25019
25020
25021 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25022   void * jresult ;
25023   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25024   Dali::FrameBufferImage result;
25025
25026   arg1 = (Dali::RenderTask *)jarg1;
25027   {
25028     try {
25029       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25030     } catch (std::out_of_range& e) {
25031       {
25032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25033       };
25034     } catch (std::exception& e) {
25035       {
25036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25037       };
25038     } catch (...) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25041       };
25042     }
25043   }
25044   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25045   return jresult;
25046 }
25047
25048
25049 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25050   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25051   Dali::FrameBuffer arg2 ;
25052   Dali::FrameBuffer *argp2 ;
25053
25054   arg1 = (Dali::RenderTask *)jarg1;
25055   argp2 = (Dali::FrameBuffer *)jarg2;
25056   if (!argp2) {
25057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25058     return ;
25059   }
25060   arg2 = *argp2;
25061   {
25062     try {
25063       (arg1)->SetFrameBuffer(arg2);
25064     } catch (std::out_of_range& e) {
25065       {
25066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25067       };
25068     } catch (std::exception& e) {
25069       {
25070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25071       };
25072     } catch (...) {
25073       {
25074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25075       };
25076     }
25077   }
25078 }
25079
25080
25081 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetFrameBuffer(void * jarg1) {
25082   void * jresult ;
25083   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25084   Dali::FrameBuffer result;
25085
25086   arg1 = (Dali::RenderTask *)jarg1;
25087   {
25088     try {
25089       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25090     } catch (std::out_of_range& e) {
25091       {
25092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (std::exception& e) {
25095       {
25096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25101       };
25102     }
25103   }
25104   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25105   return jresult;
25106 }
25107
25108
25109 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25110   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25111   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25112
25113   arg1 = (Dali::RenderTask *)jarg1;
25114   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25115   {
25116     try {
25117       (arg1)->SetScreenToFrameBufferFunction(arg2);
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25125       };
25126     } catch (...) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25129       };
25130     }
25131   }
25132 }
25133
25134
25135 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25136   void * jresult ;
25137   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25138   Dali::RenderTask::ScreenToFrameBufferFunction result;
25139
25140   arg1 = (Dali::RenderTask *)jarg1;
25141   {
25142     try {
25143       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25144     } catch (std::out_of_range& e) {
25145       {
25146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25147       };
25148     } catch (std::exception& e) {
25149       {
25150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25151       };
25152     } catch (...) {
25153       {
25154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25155       };
25156     }
25157   }
25158   jresult = (void *)result;
25159   return jresult;
25160 }
25161
25162
25163 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25164   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25165   Dali::Actor arg2 ;
25166   Dali::Actor *argp2 ;
25167
25168   arg1 = (Dali::RenderTask *)jarg1;
25169   argp2 = (Dali::Actor *)jarg2;
25170   if (!argp2) {
25171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25172     return ;
25173   }
25174   arg2 = *argp2;
25175   {
25176     try {
25177       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25178     } catch (std::out_of_range& e) {
25179       {
25180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25181       };
25182     } catch (std::exception& e) {
25183       {
25184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25185       };
25186     } catch (...) {
25187       {
25188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25189       };
25190     }
25191   }
25192 }
25193
25194
25195 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25196   void * jresult ;
25197   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25198   Dali::Actor result;
25199
25200   arg1 = (Dali::RenderTask *)jarg1;
25201   {
25202     try {
25203       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25204     } catch (std::out_of_range& e) {
25205       {
25206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25207       };
25208     } catch (std::exception& e) {
25209       {
25210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25211       };
25212     } catch (...) {
25213       {
25214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25215       };
25216     }
25217   }
25218   jresult = new Dali::Actor((const Dali::Actor &)result);
25219   return jresult;
25220 }
25221
25222
25223 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25224   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25225   Dali::Vector2 arg2 ;
25226   Dali::Vector2 *argp2 ;
25227
25228   arg1 = (Dali::RenderTask *)jarg1;
25229   argp2 = (Dali::Vector2 *)jarg2;
25230   if (!argp2) {
25231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25232     return ;
25233   }
25234   arg2 = *argp2;
25235   {
25236     try {
25237       (arg1)->SetViewportPosition(arg2);
25238     } catch (std::out_of_range& e) {
25239       {
25240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25241       };
25242     } catch (std::exception& e) {
25243       {
25244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25249       };
25250     }
25251   }
25252 }
25253
25254
25255 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25256   void * jresult ;
25257   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25258   Dali::Vector2 result;
25259
25260   arg1 = (Dali::RenderTask *)jarg1;
25261   {
25262     try {
25263       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25264     } catch (std::out_of_range& e) {
25265       {
25266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25267       };
25268     } catch (std::exception& e) {
25269       {
25270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25271       };
25272     } catch (...) {
25273       {
25274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25275       };
25276     }
25277   }
25278   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25279   return jresult;
25280 }
25281
25282
25283 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25284   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25285   Dali::Vector2 arg2 ;
25286   Dali::Vector2 *argp2 ;
25287
25288   arg1 = (Dali::RenderTask *)jarg1;
25289   argp2 = (Dali::Vector2 *)jarg2;
25290   if (!argp2) {
25291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25292     return ;
25293   }
25294   arg2 = *argp2;
25295   {
25296     try {
25297       (arg1)->SetViewportSize(arg2);
25298     } catch (std::out_of_range& e) {
25299       {
25300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25301       };
25302     } catch (std::exception& e) {
25303       {
25304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25305       };
25306     } catch (...) {
25307       {
25308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25309       };
25310     }
25311   }
25312 }
25313
25314
25315 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCurrentViewportSize(void * jarg1) {
25316   void * jresult ;
25317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25318   Dali::Vector2 result;
25319
25320   arg1 = (Dali::RenderTask *)jarg1;
25321   {
25322     try {
25323       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25324     } catch (std::out_of_range& e) {
25325       {
25326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25327       };
25328     } catch (std::exception& e) {
25329       {
25330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25331       };
25332     } catch (...) {
25333       {
25334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25335       };
25336     }
25337   }
25338   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25339   return jresult;
25340 }
25341
25342
25343 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25344   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25345   Dali::Viewport arg2 ;
25346   Dali::Viewport *argp2 ;
25347
25348   arg1 = (Dali::RenderTask *)jarg1;
25349   argp2 = (Dali::Viewport *)jarg2;
25350   if (!argp2) {
25351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25352     return ;
25353   }
25354   arg2 = *argp2;
25355   {
25356     try {
25357       (arg1)->SetViewport(arg2);
25358     } catch (std::out_of_range& e) {
25359       {
25360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25361       };
25362     } catch (std::exception& e) {
25363       {
25364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25365       };
25366     } catch (...) {
25367       {
25368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25369       };
25370     }
25371   }
25372 }
25373
25374
25375 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetViewport(void * jarg1) {
25376   void * jresult ;
25377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25378   Dali::Viewport result;
25379
25380   arg1 = (Dali::RenderTask *)jarg1;
25381   {
25382     try {
25383       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25384     } catch (std::out_of_range& e) {
25385       {
25386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25387       };
25388     } catch (std::exception& e) {
25389       {
25390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25391       };
25392     } catch (...) {
25393       {
25394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25395       };
25396     }
25397   }
25398   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25399   return jresult;
25400 }
25401
25402
25403 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25405   Dali::Vector4 *arg2 = 0 ;
25406
25407   arg1 = (Dali::RenderTask *)jarg1;
25408   arg2 = (Dali::Vector4 *)jarg2;
25409   if (!arg2) {
25410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25411     return ;
25412   }
25413   {
25414     try {
25415       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25416     } catch (std::out_of_range& e) {
25417       {
25418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25419       };
25420     } catch (std::exception& e) {
25421       {
25422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25423       };
25424     } catch (...) {
25425       {
25426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25427       };
25428     }
25429   }
25430 }
25431
25432
25433 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetClearColor(void * jarg1) {
25434   void * jresult ;
25435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25436   Dali::Vector4 result;
25437
25438   arg1 = (Dali::RenderTask *)jarg1;
25439   {
25440     try {
25441       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25442     } catch (std::out_of_range& e) {
25443       {
25444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25445       };
25446     } catch (std::exception& e) {
25447       {
25448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25449       };
25450     } catch (...) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25453       };
25454     }
25455   }
25456   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25457   return jresult;
25458 }
25459
25460
25461 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25462   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25463   bool arg2 ;
25464
25465   arg1 = (Dali::RenderTask *)jarg1;
25466   arg2 = jarg2 ? true : false;
25467   {
25468     try {
25469       (arg1)->SetClearEnabled(arg2);
25470     } catch (std::out_of_range& e) {
25471       {
25472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25473       };
25474     } catch (std::exception& e) {
25475       {
25476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25477       };
25478     } catch (...) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25481       };
25482     }
25483   }
25484 }
25485
25486
25487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetClearEnabled(void * jarg1) {
25488   unsigned int jresult ;
25489   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25490   bool result;
25491
25492   arg1 = (Dali::RenderTask *)jarg1;
25493   {
25494     try {
25495       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25496     } catch (std::out_of_range& e) {
25497       {
25498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25499       };
25500     } catch (std::exception& e) {
25501       {
25502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25503       };
25504     } catch (...) {
25505       {
25506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25507       };
25508     }
25509   }
25510   jresult = result;
25511   return jresult;
25512 }
25513
25514
25515 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25516   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25517   bool arg2 ;
25518
25519   arg1 = (Dali::RenderTask *)jarg1;
25520   arg2 = jarg2 ? true : false;
25521   {
25522     try {
25523       (arg1)->SetCullMode(arg2);
25524     } catch (std::out_of_range& e) {
25525       {
25526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25527       };
25528     } catch (std::exception& e) {
25529       {
25530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25531       };
25532     } catch (...) {
25533       {
25534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25535       };
25536     }
25537   }
25538 }
25539
25540
25541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetCullMode(void * jarg1) {
25542   unsigned int jresult ;
25543   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25544   bool result;
25545
25546   arg1 = (Dali::RenderTask *)jarg1;
25547   {
25548     try {
25549       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25550     } catch (std::out_of_range& e) {
25551       {
25552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (std::exception& e) {
25555       {
25556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25561       };
25562     }
25563   }
25564   jresult = result;
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25571   unsigned int arg2 ;
25572
25573   arg1 = (Dali::RenderTask *)jarg1;
25574   arg2 = (unsigned int)jarg2;
25575   {
25576     try {
25577       (arg1)->SetRefreshRate(arg2);
25578     } catch (std::out_of_range& e) {
25579       {
25580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25581       };
25582     } catch (std::exception& e) {
25583       {
25584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25585       };
25586     } catch (...) {
25587       {
25588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25589       };
25590     }
25591   }
25592 }
25593
25594
25595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetRefreshRate(void * jarg1) {
25596   unsigned int jresult ;
25597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25598   unsigned int result;
25599
25600   arg1 = (Dali::RenderTask *)jarg1;
25601   {
25602     try {
25603       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25611       };
25612     } catch (...) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25615       };
25616     }
25617   }
25618   jresult = result;
25619   return jresult;
25620 }
25621
25622
25623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25624   unsigned int jresult ;
25625   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25626   Dali::Vector3 *arg2 = 0 ;
25627   float *arg3 = 0 ;
25628   float *arg4 = 0 ;
25629   bool result;
25630
25631   arg1 = (Dali::RenderTask *)jarg1;
25632   arg2 = (Dali::Vector3 *)jarg2;
25633   if (!arg2) {
25634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25635     return 0;
25636   }
25637   arg3 = (float *)jarg3;
25638   arg4 = (float *)jarg4;
25639   {
25640     try {
25641       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25642     } catch (std::out_of_range& e) {
25643       {
25644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25645       };
25646     } catch (std::exception& e) {
25647       {
25648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25649       };
25650     } catch (...) {
25651       {
25652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25653       };
25654     }
25655   }
25656   jresult = result;
25657   return jresult;
25658 }
25659
25660
25661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25662   unsigned int jresult ;
25663   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25664   Dali::Actor arg2 ;
25665   float arg3 ;
25666   float arg4 ;
25667   float *arg5 = 0 ;
25668   float *arg6 = 0 ;
25669   Dali::Actor *argp2 ;
25670   bool result;
25671
25672   arg1 = (Dali::RenderTask *)jarg1;
25673   argp2 = (Dali::Actor *)jarg2;
25674   if (!argp2) {
25675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25676     return 0;
25677   }
25678   arg2 = *argp2;
25679   arg3 = (float)jarg3;
25680   arg4 = (float)jarg4;
25681   arg5 = (float *)jarg5;
25682   arg6 = (float *)jarg6;
25683   {
25684     try {
25685       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25686     } catch (std::out_of_range& e) {
25687       {
25688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (std::exception& e) {
25691       {
25692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (...) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25697       };
25698     }
25699   }
25700   jresult = result;
25701   return jresult;
25702 }
25703
25704
25705 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_FinishedSignal(void * jarg1) {
25706   void * jresult ;
25707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25708   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25709
25710   arg1 = (Dali::RenderTask *)jarg1;
25711   {
25712     try {
25713       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25714     } catch (std::out_of_range& e) {
25715       {
25716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25717       };
25718     } catch (std::exception& e) {
25719       {
25720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (...) {
25723       {
25724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25725       };
25726     }
25727   }
25728   jresult = (void *)result;
25729   return jresult;
25730 }
25731
25732
25733 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25734   void * jresult ;
25735   int arg1 ;
25736   Dali::TouchPoint::State arg2 ;
25737   float arg3 ;
25738   float arg4 ;
25739   Dali::TouchPoint *result = 0 ;
25740
25741   arg1 = (int)jarg1;
25742   arg2 = (Dali::TouchPoint::State)jarg2;
25743   arg3 = (float)jarg3;
25744   arg4 = (float)jarg4;
25745   {
25746     try {
25747       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (...) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25759       };
25760     }
25761   }
25762   jresult = (void *)result;
25763   return jresult;
25764 }
25765
25766
25767 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25768   void * jresult ;
25769   int arg1 ;
25770   Dali::TouchPoint::State arg2 ;
25771   float arg3 ;
25772   float arg4 ;
25773   float arg5 ;
25774   float arg6 ;
25775   Dali::TouchPoint *result = 0 ;
25776
25777   arg1 = (int)jarg1;
25778   arg2 = (Dali::TouchPoint::State)jarg2;
25779   arg3 = (float)jarg3;
25780   arg4 = (float)jarg4;
25781   arg5 = (float)jarg5;
25782   arg6 = (float)jarg6;
25783   {
25784     try {
25785       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25797       };
25798     }
25799   }
25800   jresult = (void *)result;
25801   return jresult;
25802 }
25803
25804
25805 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchPoint(void * jarg1) {
25806   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25807
25808   arg1 = (Dali::TouchPoint *)jarg1;
25809   {
25810     try {
25811       delete arg1;
25812     } catch (std::out_of_range& e) {
25813       {
25814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25815       };
25816     } catch (std::exception& e) {
25817       {
25818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25819       };
25820     } catch (...) {
25821       {
25822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25823       };
25824     }
25825   }
25826 }
25827
25828
25829 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25830   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25831   int arg2 ;
25832
25833   arg1 = (Dali::TouchPoint *)jarg1;
25834   arg2 = (int)jarg2;
25835   if (arg1) (arg1)->deviceId = arg2;
25836 }
25837
25838
25839 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchPoint_deviceId_get(void * jarg1) {
25840   int jresult ;
25841   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25842   int result;
25843
25844   arg1 = (Dali::TouchPoint *)jarg1;
25845   result = (int) ((arg1)->deviceId);
25846   jresult = result;
25847   return jresult;
25848 }
25849
25850
25851 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_state_set(void * jarg1, int jarg2) {
25852   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25853   Dali::TouchPoint::State arg2 ;
25854
25855   arg1 = (Dali::TouchPoint *)jarg1;
25856   arg2 = (Dali::TouchPoint::State)jarg2;
25857   if (arg1) (arg1)->state = arg2;
25858 }
25859
25860
25861 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchPoint_state_get(void * jarg1) {
25862   int jresult ;
25863   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25864   Dali::TouchPoint::State result;
25865
25866   arg1 = (Dali::TouchPoint *)jarg1;
25867   result = (Dali::TouchPoint::State) ((arg1)->state);
25868   jresult = (int)result;
25869   return jresult;
25870 }
25871
25872
25873 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25874   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25875   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25876
25877   arg1 = (Dali::TouchPoint *)jarg1;
25878   arg2 = (Dali::Actor *)jarg2;
25879   if (arg1) (arg1)->hitActor = *arg2;
25880 }
25881
25882
25883 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_hitActor_get(void * jarg1) {
25884   void * jresult ;
25885   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25886   Dali::Actor *result = 0 ;
25887
25888   arg1 = (Dali::TouchPoint *)jarg1;
25889   result = (Dali::Actor *)& ((arg1)->hitActor);
25890   jresult = (void *)result;
25891   return jresult;
25892 }
25893
25894
25895 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_local_set(void * jarg1, void * jarg2) {
25896   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25897   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25898
25899   arg1 = (Dali::TouchPoint *)jarg1;
25900   arg2 = (Dali::Vector2 *)jarg2;
25901   if (arg1) (arg1)->local = *arg2;
25902 }
25903
25904
25905 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_local_get(void * jarg1) {
25906   void * jresult ;
25907   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25908   Dali::Vector2 *result = 0 ;
25909
25910   arg1 = (Dali::TouchPoint *)jarg1;
25911   result = (Dali::Vector2 *)& ((arg1)->local);
25912   jresult = (void *)result;
25913   return jresult;
25914 }
25915
25916
25917 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_screen_set(void * jarg1, void * jarg2) {
25918   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25919   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25920
25921   arg1 = (Dali::TouchPoint *)jarg1;
25922   arg2 = (Dali::Vector2 *)jarg2;
25923   if (arg1) (arg1)->screen = *arg2;
25924 }
25925
25926
25927 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_screen_get(void * jarg1) {
25928   void * jresult ;
25929   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25930   Dali::Vector2 *result = 0 ;
25931
25932   arg1 = (Dali::TouchPoint *)jarg1;
25933   result = (Dali::Vector2 *)& ((arg1)->screen);
25934   jresult = (void *)result;
25935   return jresult;
25936 }
25937
25938
25939 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchData__SWIG_0() {
25940   void * jresult ;
25941   Dali::TouchData *result = 0 ;
25942
25943   {
25944     try {
25945       result = (Dali::TouchData *)new Dali::TouchData();
25946     } catch (std::out_of_range& e) {
25947       {
25948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25949       };
25950     } catch (std::exception& e) {
25951       {
25952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25953       };
25954     } catch (...) {
25955       {
25956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25957       };
25958     }
25959   }
25960   jresult = (void *)result;
25961   return jresult;
25962 }
25963
25964
25965 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchData__SWIG_1(void * jarg1) {
25966   void * jresult ;
25967   Dali::TouchData *arg1 = 0 ;
25968   Dali::TouchData *result = 0 ;
25969
25970   arg1 = (Dali::TouchData *)jarg1;
25971   if (!arg1) {
25972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
25973     return 0;
25974   }
25975   {
25976     try {
25977       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
25978     } catch (std::out_of_range& e) {
25979       {
25980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25981       };
25982     } catch (std::exception& e) {
25983       {
25984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25985       };
25986     } catch (...) {
25987       {
25988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25989       };
25990     }
25991   }
25992   jresult = (void *)result;
25993   return jresult;
25994 }
25995
25996
25997 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchData(void * jarg1) {
25998   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
25999
26000   arg1 = (Dali::TouchData *)jarg1;
26001   {
26002     try {
26003       delete arg1;
26004     } catch (std::out_of_range& e) {
26005       {
26006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (std::exception& e) {
26009       {
26010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26011       };
26012     } catch (...) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26015       };
26016     }
26017   }
26018 }
26019
26020
26021 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_Assign(void * jarg1, void * jarg2) {
26022   void * jresult ;
26023   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26024   Dali::TouchData *arg2 = 0 ;
26025   Dali::TouchData *result = 0 ;
26026
26027   arg1 = (Dali::TouchData *)jarg1;
26028   arg2 = (Dali::TouchData *)jarg2;
26029   if (!arg2) {
26030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26031     return 0;
26032   }
26033   {
26034     try {
26035       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26036     } catch (std::out_of_range& e) {
26037       {
26038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26039       };
26040     } catch (std::exception& e) {
26041       {
26042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26043       };
26044     } catch (...) {
26045       {
26046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26047       };
26048     }
26049   }
26050   jresult = (void *)result;
26051   return jresult;
26052 }
26053
26054
26055 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchData_GetTime(void * jarg1) {
26056   unsigned long jresult ;
26057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26058   unsigned long result;
26059
26060   arg1 = (Dali::TouchData *)jarg1;
26061   {
26062     try {
26063       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26064     } catch (std::out_of_range& e) {
26065       {
26066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26067       };
26068     } catch (std::exception& e) {
26069       {
26070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26071       };
26072     } catch (...) {
26073       {
26074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26075       };
26076     }
26077   }
26078   jresult = (unsigned long)result;
26079   return jresult;
26080 }
26081
26082
26083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchData_GetPointCount(void * jarg1) {
26084   unsigned long jresult ;
26085   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26086   std::size_t result;
26087
26088   arg1 = (Dali::TouchData *)jarg1;
26089   {
26090     try {
26091       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26092     } catch (std::out_of_range& e) {
26093       {
26094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26095       };
26096     } catch (std::exception& e) {
26097       {
26098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26099       };
26100     } catch (...) {
26101       {
26102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26103       };
26104     }
26105   }
26106   jresult = (unsigned long)result;
26107   return jresult;
26108 }
26109
26110
26111 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchData_GetDeviceId(void * jarg1, unsigned long jarg2) {
26112   int jresult ;
26113   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26114   std::size_t arg2 ;
26115   int32_t result;
26116
26117   arg1 = (Dali::TouchData *)jarg1;
26118   arg2 = (std::size_t)jarg2;
26119   {
26120     try {
26121       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26122     } catch (std::out_of_range& e) {
26123       {
26124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26125       };
26126     } catch (std::exception& e) {
26127       {
26128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26129       };
26130     } catch (...) {
26131       {
26132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26133       };
26134     }
26135   }
26136   jresult = result;
26137   return jresult;
26138 }
26139
26140
26141 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchData_GetState(void * jarg1, unsigned long jarg2) {
26142   int jresult ;
26143   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26144   std::size_t arg2 ;
26145   Dali::PointState::Type result;
26146
26147   arg1 = (Dali::TouchData *)jarg1;
26148   arg2 = (std::size_t)jarg2;
26149   {
26150     try {
26151       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26152     } catch (std::out_of_range& e) {
26153       {
26154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26155       };
26156     } catch (std::exception& e) {
26157       {
26158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26159       };
26160     } catch (...) {
26161       {
26162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26163       };
26164     }
26165   }
26166   jresult = (int)result;
26167   return jresult;
26168 }
26169
26170
26171 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetHitActor(void * jarg1, unsigned long jarg2) {
26172   void * jresult ;
26173   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26174   std::size_t arg2 ;
26175   Dali::Actor result;
26176
26177   arg1 = (Dali::TouchData *)jarg1;
26178   arg2 = (std::size_t)jarg2;
26179   {
26180     try {
26181       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26182     } catch (std::out_of_range& e) {
26183       {
26184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26185       };
26186     } catch (std::exception& e) {
26187       {
26188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26189       };
26190     } catch (...) {
26191       {
26192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26193       };
26194     }
26195   }
26196   jresult = new Dali::Actor((const Dali::Actor &)result);
26197   return jresult;
26198 }
26199
26200
26201 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26202   void * jresult ;
26203   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26204   std::size_t arg2 ;
26205   Dali::Vector2 *result = 0 ;
26206
26207   arg1 = (Dali::TouchData *)jarg1;
26208   arg2 = (std::size_t)jarg2;
26209   {
26210     try {
26211       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26212     } catch (std::out_of_range& e) {
26213       {
26214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26215       };
26216     } catch (std::exception& e) {
26217       {
26218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26219       };
26220     } catch (...) {
26221       {
26222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26223       };
26224     }
26225   }
26226   jresult = (void *)result;
26227   return jresult;
26228 }
26229
26230
26231 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26232   void * jresult ;
26233   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26234   std::size_t arg2 ;
26235   Dali::Vector2 *result = 0 ;
26236
26237   arg1 = (Dali::TouchData *)jarg1;
26238   arg2 = (std::size_t)jarg2;
26239   {
26240     try {
26241       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26242     } catch (std::out_of_range& e) {
26243       {
26244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26245       };
26246     } catch (std::exception& e) {
26247       {
26248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26249       };
26250     } catch (...) {
26251       {
26252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26253       };
26254     }
26255   }
26256   jresult = (void *)result;
26257   return jresult;
26258 }
26259
26260
26261 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TouchData_GetRadius(void * jarg1, unsigned long jarg2) {
26262   float jresult ;
26263   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26264   std::size_t arg2 ;
26265   float result;
26266
26267   arg1 = (Dali::TouchData *)jarg1;
26268   arg2 = (std::size_t)jarg2;
26269   {
26270     try {
26271       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26272     } catch (std::out_of_range& e) {
26273       {
26274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26275       };
26276     } catch (std::exception& e) {
26277       {
26278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26279       };
26280     } catch (...) {
26281       {
26282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26283       };
26284     }
26285   }
26286   jresult = result;
26287   return jresult;
26288 }
26289
26290
26291 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26292   void * jresult ;
26293   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26294   std::size_t arg2 ;
26295   Dali::Vector2 *result = 0 ;
26296
26297   arg1 = (Dali::TouchData *)jarg1;
26298   arg2 = (std::size_t)jarg2;
26299   {
26300     try {
26301       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26302     } catch (std::out_of_range& e) {
26303       {
26304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26305       };
26306     } catch (std::exception& e) {
26307       {
26308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26309       };
26310     } catch (...) {
26311       {
26312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26313       };
26314     }
26315   }
26316   jresult = (void *)result;
26317   return jresult;
26318 }
26319
26320
26321 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TouchData_GetPressure(void * jarg1, unsigned long jarg2) {
26322   float jresult ;
26323   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26324   std::size_t arg2 ;
26325   float result;
26326
26327   arg1 = (Dali::TouchData *)jarg1;
26328   arg2 = (std::size_t)jarg2;
26329   {
26330     try {
26331       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26332     } catch (std::out_of_range& e) {
26333       {
26334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26335       };
26336     } catch (std::exception& e) {
26337       {
26338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26339       };
26340     } catch (...) {
26341       {
26342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26343       };
26344     }
26345   }
26346   jresult = result;
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetAngle(void * jarg1, unsigned long jarg2) {
26352   void * jresult ;
26353   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26354   std::size_t arg2 ;
26355   Dali::Degree result;
26356
26357   arg1 = (Dali::TouchData *)jarg1;
26358   arg2 = (std::size_t)jarg2;
26359   {
26360     try {
26361       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (...) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26373       };
26374     }
26375   }
26376   jresult = new Dali::Degree((const Dali::Degree &)result);
26377   return jresult;
26378 }
26379
26380
26381 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GestureDetector__SWIG_0() {
26382   void * jresult ;
26383   Dali::GestureDetector *result = 0 ;
26384
26385   {
26386     try {
26387       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26388     } catch (std::out_of_range& e) {
26389       {
26390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26391       };
26392     } catch (std::exception& e) {
26393       {
26394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26395       };
26396     } catch (...) {
26397       {
26398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26399       };
26400     }
26401   }
26402   jresult = (void *)result;
26403   return jresult;
26404 }
26405
26406
26407 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_DownCast(void * jarg1) {
26408   void * jresult ;
26409   Dali::BaseHandle arg1 ;
26410   Dali::BaseHandle *argp1 ;
26411   Dali::GestureDetector result;
26412
26413   argp1 = (Dali::BaseHandle *)jarg1;
26414   if (!argp1) {
26415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26416     return 0;
26417   }
26418   arg1 = *argp1;
26419   {
26420     try {
26421       result = Dali::GestureDetector::DownCast(arg1);
26422     } catch (std::out_of_range& e) {
26423       {
26424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26425       };
26426     } catch (std::exception& e) {
26427       {
26428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26429       };
26430     } catch (...) {
26431       {
26432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26433       };
26434     }
26435   }
26436   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26437   return jresult;
26438 }
26439
26440
26441 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GestureDetector(void * jarg1) {
26442   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26443
26444   arg1 = (Dali::GestureDetector *)jarg1;
26445   {
26446     try {
26447       delete arg1;
26448     } catch (std::out_of_range& e) {
26449       {
26450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26451       };
26452     } catch (std::exception& e) {
26453       {
26454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26455       };
26456     } catch (...) {
26457       {
26458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26459       };
26460     }
26461   }
26462 }
26463
26464
26465 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GestureDetector__SWIG_1(void * jarg1) {
26466   void * jresult ;
26467   Dali::GestureDetector *arg1 = 0 ;
26468   Dali::GestureDetector *result = 0 ;
26469
26470   arg1 = (Dali::GestureDetector *)jarg1;
26471   if (!arg1) {
26472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26473     return 0;
26474   }
26475   {
26476     try {
26477       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26478     } catch (std::out_of_range& e) {
26479       {
26480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26481       };
26482     } catch (std::exception& e) {
26483       {
26484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26485       };
26486     } catch (...) {
26487       {
26488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26489       };
26490     }
26491   }
26492   jresult = (void *)result;
26493   return jresult;
26494 }
26495
26496
26497 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_Assign(void * jarg1, void * jarg2) {
26498   void * jresult ;
26499   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26500   Dali::GestureDetector *arg2 = 0 ;
26501   Dali::GestureDetector *result = 0 ;
26502
26503   arg1 = (Dali::GestureDetector *)jarg1;
26504   arg2 = (Dali::GestureDetector *)jarg2;
26505   if (!arg2) {
26506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26507     return 0;
26508   }
26509   {
26510     try {
26511       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26512     } catch (std::out_of_range& e) {
26513       {
26514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26515       };
26516     } catch (std::exception& e) {
26517       {
26518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26519       };
26520     } catch (...) {
26521       {
26522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26523       };
26524     }
26525   }
26526   jresult = (void *)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_Attach(void * jarg1, void * jarg2) {
26532   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26533   Dali::Actor arg2 ;
26534   Dali::Actor *argp2 ;
26535
26536   arg1 = (Dali::GestureDetector *)jarg1;
26537   argp2 = (Dali::Actor *)jarg2;
26538   if (!argp2) {
26539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26540     return ;
26541   }
26542   arg2 = *argp2;
26543   {
26544     try {
26545       (arg1)->Attach(arg2);
26546     } catch (std::out_of_range& e) {
26547       {
26548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26549       };
26550     } catch (std::exception& e) {
26551       {
26552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26553       };
26554     } catch (...) {
26555       {
26556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26557       };
26558     }
26559   }
26560 }
26561
26562
26563 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_Detach(void * jarg1, void * jarg2) {
26564   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26565   Dali::Actor arg2 ;
26566   Dali::Actor *argp2 ;
26567
26568   arg1 = (Dali::GestureDetector *)jarg1;
26569   argp2 = (Dali::Actor *)jarg2;
26570   if (!argp2) {
26571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26572     return ;
26573   }
26574   arg2 = *argp2;
26575   {
26576     try {
26577       (arg1)->Detach(arg2);
26578     } catch (std::out_of_range& e) {
26579       {
26580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26581       };
26582     } catch (std::exception& e) {
26583       {
26584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26585       };
26586     } catch (...) {
26587       {
26588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26589       };
26590     }
26591   }
26592 }
26593
26594
26595 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_DetachAll(void * jarg1) {
26596   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26597
26598   arg1 = (Dali::GestureDetector *)jarg1;
26599   {
26600     try {
26601       (arg1)->DetachAll();
26602     } catch (std::out_of_range& e) {
26603       {
26604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26605       };
26606     } catch (std::exception& e) {
26607       {
26608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26609       };
26610     } catch (...) {
26611       {
26612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26613       };
26614     }
26615   }
26616 }
26617
26618
26619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_GestureDetector_GetAttachedActorCount(void * jarg1) {
26620   unsigned long jresult ;
26621   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26622   size_t result;
26623
26624   arg1 = (Dali::GestureDetector *)jarg1;
26625   {
26626     try {
26627       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26628     } catch (std::out_of_range& e) {
26629       {
26630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26631       };
26632     } catch (std::exception& e) {
26633       {
26634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26635       };
26636     } catch (...) {
26637       {
26638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26639       };
26640     }
26641   }
26642   jresult = (unsigned long)result;
26643   return jresult;
26644 }
26645
26646
26647 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26648   void * jresult ;
26649   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26650   size_t arg2 ;
26651   Dali::Actor result;
26652
26653   arg1 = (Dali::GestureDetector *)jarg1;
26654   arg2 = (size_t)jarg2;
26655   {
26656     try {
26657       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26658     } catch (std::out_of_range& e) {
26659       {
26660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26661       };
26662     } catch (std::exception& e) {
26663       {
26664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26665       };
26666     } catch (...) {
26667       {
26668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26669       };
26670     }
26671   }
26672   jresult = new Dali::Actor((const Dali::Actor &)result);
26673   return jresult;
26674 }
26675
26676
26677 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Gesture(void * jarg1) {
26678   void * jresult ;
26679   Dali::Gesture *arg1 = 0 ;
26680   Dali::Gesture *result = 0 ;
26681
26682   arg1 = (Dali::Gesture *)jarg1;
26683   if (!arg1) {
26684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26685     return 0;
26686   }
26687   {
26688     try {
26689       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26690     } catch (std::out_of_range& e) {
26691       {
26692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26693       };
26694     } catch (std::exception& e) {
26695       {
26696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26697       };
26698     } catch (...) {
26699       {
26700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26701       };
26702     }
26703   }
26704   jresult = (void *)result;
26705   return jresult;
26706 }
26707
26708
26709 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Gesture_Assign(void * jarg1, void * jarg2) {
26710   void * jresult ;
26711   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26712   Dali::Gesture *arg2 = 0 ;
26713   Dali::Gesture *result = 0 ;
26714
26715   arg1 = (Dali::Gesture *)jarg1;
26716   arg2 = (Dali::Gesture *)jarg2;
26717   if (!arg2) {
26718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26719     return 0;
26720   }
26721   {
26722     try {
26723       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26724     } catch (std::out_of_range& e) {
26725       {
26726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26727       };
26728     } catch (std::exception& e) {
26729       {
26730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26731       };
26732     } catch (...) {
26733       {
26734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26735       };
26736     }
26737   }
26738   jresult = (void *)result;
26739   return jresult;
26740 }
26741
26742
26743 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Gesture(void * jarg1) {
26744   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26745
26746   arg1 = (Dali::Gesture *)jarg1;
26747   {
26748     try {
26749       delete arg1;
26750     } catch (std::out_of_range& e) {
26751       {
26752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26753       };
26754     } catch (std::exception& e) {
26755       {
26756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26757       };
26758     } catch (...) {
26759       {
26760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26761       };
26762     }
26763   }
26764 }
26765
26766
26767 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_type_set(void * jarg1, int jarg2) {
26768   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26769   Dali::Gesture::Type arg2 ;
26770
26771   arg1 = (Dali::Gesture *)jarg1;
26772   arg2 = (Dali::Gesture::Type)jarg2;
26773   if (arg1) (arg1)->type = arg2;
26774 }
26775
26776
26777 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Gesture_type_get(void * jarg1) {
26778   int jresult ;
26779   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26780   Dali::Gesture::Type result;
26781
26782   arg1 = (Dali::Gesture *)jarg1;
26783   result = (Dali::Gesture::Type) ((arg1)->type);
26784   jresult = (int)result;
26785   return jresult;
26786 }
26787
26788
26789 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_state_set(void * jarg1, int jarg2) {
26790   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26791   Dali::Gesture::State arg2 ;
26792
26793   arg1 = (Dali::Gesture *)jarg1;
26794   arg2 = (Dali::Gesture::State)jarg2;
26795   if (arg1) (arg1)->state = arg2;
26796 }
26797
26798
26799 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Gesture_state_get(void * jarg1) {
26800   int jresult ;
26801   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26802   Dali::Gesture::State result;
26803
26804   arg1 = (Dali::Gesture *)jarg1;
26805   result = (Dali::Gesture::State) ((arg1)->state);
26806   jresult = (int)result;
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26812   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26813   unsigned int arg2 ;
26814
26815   arg1 = (Dali::Gesture *)jarg1;
26816   arg2 = (unsigned int)jarg2;
26817   if (arg1) (arg1)->time = arg2;
26818 }
26819
26820
26821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Gesture_time_get(void * jarg1) {
26822   unsigned int jresult ;
26823   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26824   unsigned int result;
26825
26826   arg1 = (Dali::Gesture *)jarg1;
26827   result = (unsigned int) ((arg1)->time);
26828   jresult = result;
26829   return jresult;
26830 }
26831
26832
26833 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_HoverEvent__SWIG_0() {
26834   void * jresult ;
26835   Dali::HoverEvent *result = 0 ;
26836
26837   {
26838     try {
26839       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26840     } catch (std::out_of_range& e) {
26841       {
26842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26843       };
26844     } catch (std::exception& e) {
26845       {
26846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26847       };
26848     } catch (...) {
26849       {
26850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26851       };
26852     }
26853   }
26854   jresult = (void *)result;
26855   return jresult;
26856 }
26857
26858
26859 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_HoverEvent__SWIG_1(unsigned long jarg1) {
26860   void * jresult ;
26861   unsigned long arg1 ;
26862   Dali::HoverEvent *result = 0 ;
26863
26864   arg1 = (unsigned long)jarg1;
26865   {
26866     try {
26867       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26868     } catch (std::out_of_range& e) {
26869       {
26870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26871       };
26872     } catch (std::exception& e) {
26873       {
26874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26875       };
26876     } catch (...) {
26877       {
26878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26879       };
26880     }
26881   }
26882   jresult = (void *)result;
26883   return jresult;
26884 }
26885
26886
26887 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_HoverEvent(void * jarg1) {
26888   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26889
26890   arg1 = (Dali::HoverEvent *)jarg1;
26891   {
26892     try {
26893       delete arg1;
26894     } catch (std::out_of_range& e) {
26895       {
26896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26897       };
26898     } catch (std::exception& e) {
26899       {
26900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26901       };
26902     } catch (...) {
26903       {
26904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26905       };
26906     }
26907   }
26908 }
26909
26910
26911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_HoverEvent_points_set(void * jarg1, void * jarg2) {
26912   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26913   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
26914
26915   arg1 = (Dali::HoverEvent *)jarg1;
26916   arg2 = (Dali::TouchPointContainer *)jarg2;
26917   if (arg1) (arg1)->points = *arg2;
26918 }
26919
26920
26921 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_HoverEvent_points_get(void * jarg1) {
26922   void * jresult ;
26923   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26924   Dali::TouchPointContainer *result = 0 ;
26925
26926   arg1 = (Dali::HoverEvent *)jarg1;
26927   result = (Dali::TouchPointContainer *)& ((arg1)->points);
26928   jresult = (void *)result;
26929   return jresult;
26930 }
26931
26932
26933 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_HoverEvent_time_set(void * jarg1, unsigned long jarg2) {
26934   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26935   unsigned long arg2 ;
26936
26937   arg1 = (Dali::HoverEvent *)jarg1;
26938   arg2 = (unsigned long)jarg2;
26939   if (arg1) (arg1)->time = arg2;
26940 }
26941
26942
26943 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_HoverEvent_time_get(void * jarg1) {
26944   unsigned long jresult ;
26945   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26946   unsigned long result;
26947
26948   arg1 = (Dali::HoverEvent *)jarg1;
26949   result = (unsigned long) ((arg1)->time);
26950   jresult = (unsigned long)result;
26951   return jresult;
26952 }
26953
26954
26955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_HoverEvent_GetPointCount(void * jarg1) {
26956   unsigned int jresult ;
26957   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26958   unsigned int result;
26959
26960   arg1 = (Dali::HoverEvent *)jarg1;
26961   {
26962     try {
26963       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
26964     } catch (std::out_of_range& e) {
26965       {
26966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26967       };
26968     } catch (std::exception& e) {
26969       {
26970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26971       };
26972     } catch (...) {
26973       {
26974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26975       };
26976     }
26977   }
26978   jresult = result;
26979   return jresult;
26980 }
26981
26982
26983 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_HoverEvent_GetPoint(void * jarg1, unsigned int jarg2) {
26984   void * jresult ;
26985   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26986   unsigned int arg2 ;
26987   Dali::TouchPoint *result = 0 ;
26988
26989   arg1 = (Dali::HoverEvent *)jarg1;
26990   arg2 = (unsigned int)jarg2;
26991   {
26992     try {
26993       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
26994     } catch (std::out_of_range& e) {
26995       {
26996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26997       };
26998     } catch (std::exception& e) {
26999       {
27000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27001       };
27002     } catch (...) {
27003       {
27004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27005       };
27006     }
27007   }
27008   jresult = (void *)result;
27009   return jresult;
27010 }
27011
27012
27013 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEvent__SWIG_0() {
27014   void * jresult ;
27015   Dali::KeyEvent *result = 0 ;
27016
27017   {
27018     try {
27019       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27020     } catch (std::out_of_range& e) {
27021       {
27022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27023       };
27024     } catch (std::exception& e) {
27025       {
27026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (...) {
27029       {
27030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27031       };
27032     }
27033   }
27034   jresult = (void *)result;
27035   return jresult;
27036 }
27037
27038
27039 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEvent__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27040   void * jresult ;
27041   std::string *arg1 = 0 ;
27042   std::string *arg2 = 0 ;
27043   int arg3 ;
27044   int arg4 ;
27045   unsigned long arg5 ;
27046   Dali::KeyEvent::State *arg6 = 0 ;
27047   Dali::KeyEvent::State temp6 ;
27048   Dali::KeyEvent *result = 0 ;
27049
27050   if (!jarg1) {
27051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27052     return 0;
27053   }
27054   std::string arg1_str(jarg1);
27055   arg1 = &arg1_str;
27056   if (!jarg2) {
27057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27058     return 0;
27059   }
27060   std::string arg2_str(jarg2);
27061   arg2 = &arg2_str;
27062   arg3 = (int)jarg3;
27063   arg4 = (int)jarg4;
27064   arg5 = (unsigned long)jarg5;
27065   temp6 = (Dali::KeyEvent::State)jarg6;
27066   arg6 = &temp6;
27067   {
27068     try {
27069       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27070     } catch (std::out_of_range& e) {
27071       {
27072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27073       };
27074     } catch (std::exception& e) {
27075       {
27076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27077       };
27078     } catch (...) {
27079       {
27080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27081       };
27082     }
27083   }
27084   jresult = (void *)result;
27085
27086   //argout typemap for const std::string&
27087
27088
27089   //argout typemap for const std::string&
27090
27091   return jresult;
27092 }
27093
27094
27095 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyEvent(void * jarg1) {
27096   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27097
27098   arg1 = (Dali::KeyEvent *)jarg1;
27099   {
27100     try {
27101       delete arg1;
27102     } catch (std::out_of_range& e) {
27103       {
27104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27105       };
27106     } catch (std::exception& e) {
27107       {
27108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27109       };
27110     } catch (...) {
27111       {
27112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27113       };
27114     }
27115   }
27116 }
27117
27118
27119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsShiftModifier(void * jarg1) {
27120   unsigned int jresult ;
27121   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27122   bool result;
27123
27124   arg1 = (Dali::KeyEvent *)jarg1;
27125   {
27126     try {
27127       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27128     } catch (std::out_of_range& e) {
27129       {
27130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27131       };
27132     } catch (std::exception& e) {
27133       {
27134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27135       };
27136     } catch (...) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27139       };
27140     }
27141   }
27142   jresult = result;
27143   return jresult;
27144 }
27145
27146
27147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsCtrlModifier(void * jarg1) {
27148   unsigned int jresult ;
27149   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27150   bool result;
27151
27152   arg1 = (Dali::KeyEvent *)jarg1;
27153   {
27154     try {
27155       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27156     } catch (std::out_of_range& e) {
27157       {
27158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (std::exception& e) {
27161       {
27162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27163       };
27164     } catch (...) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27167       };
27168     }
27169   }
27170   jresult = result;
27171   return jresult;
27172 }
27173
27174
27175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsAltModifier(void * jarg1) {
27176   unsigned int jresult ;
27177   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27178   bool result;
27179
27180   arg1 = (Dali::KeyEvent *)jarg1;
27181   {
27182     try {
27183       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27184     } catch (std::out_of_range& e) {
27185       {
27186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27187       };
27188     } catch (std::exception& e) {
27189       {
27190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27191       };
27192     } catch (...) {
27193       {
27194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27195       };
27196     }
27197   }
27198   jresult = result;
27199   return jresult;
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressedName_set(void * jarg1, char * jarg2) {
27204   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27205   std::string *arg2 = 0 ;
27206
27207   arg1 = (Dali::KeyEvent *)jarg1;
27208   if (!jarg2) {
27209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27210     return ;
27211   }
27212   std::string arg2_str(jarg2);
27213   arg2 = &arg2_str;
27214   if (arg1) (arg1)->keyPressedName = *arg2;
27215
27216   //argout typemap for const std::string&
27217
27218 }
27219
27220
27221 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressedName_get(void * jarg1) {
27222   char * jresult ;
27223   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27224   std::string *result = 0 ;
27225
27226   arg1 = (Dali::KeyEvent *)jarg1;
27227   result = (std::string *) & ((arg1)->keyPressedName);
27228   jresult = SWIG_csharp_string_callback(result->c_str());
27229   return jresult;
27230 }
27231
27232
27233 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressed_set(void * jarg1, char * jarg2) {
27234   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27235   std::string *arg2 = 0 ;
27236
27237   arg1 = (Dali::KeyEvent *)jarg1;
27238   if (!jarg2) {
27239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27240     return ;
27241   }
27242   std::string arg2_str(jarg2);
27243   arg2 = &arg2_str;
27244   if (arg1) (arg1)->keyPressed = *arg2;
27245
27246   //argout typemap for const std::string&
27247
27248 }
27249
27250
27251 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressed_get(void * jarg1) {
27252   char * jresult ;
27253   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27254   std::string *result = 0 ;
27255
27256   arg1 = (Dali::KeyEvent *)jarg1;
27257   result = (std::string *) & ((arg1)->keyPressed);
27258   jresult = SWIG_csharp_string_callback(result->c_str());
27259   return jresult;
27260 }
27261
27262
27263 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyCode_set(void * jarg1, int jarg2) {
27264   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27265   int arg2 ;
27266
27267   arg1 = (Dali::KeyEvent *)jarg1;
27268   arg2 = (int)jarg2;
27269   if (arg1) (arg1)->keyCode = arg2;
27270 }
27271
27272
27273 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_keyCode_get(void * jarg1) {
27274   int jresult ;
27275   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27276   int result;
27277
27278   arg1 = (Dali::KeyEvent *)jarg1;
27279   result = (int) ((arg1)->keyCode);
27280   jresult = result;
27281   return jresult;
27282 }
27283
27284
27285 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyModifier_set(void * jarg1, int jarg2) {
27286   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27287   int arg2 ;
27288
27289   arg1 = (Dali::KeyEvent *)jarg1;
27290   arg2 = (int)jarg2;
27291   if (arg1) (arg1)->keyModifier = arg2;
27292 }
27293
27294
27295 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_keyModifier_get(void * jarg1) {
27296   int jresult ;
27297   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27298   int result;
27299
27300   arg1 = (Dali::KeyEvent *)jarg1;
27301   result = (int) ((arg1)->keyModifier);
27302   jresult = result;
27303   return jresult;
27304 }
27305
27306
27307 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_time_set(void * jarg1, unsigned long jarg2) {
27308   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27309   unsigned long arg2 ;
27310
27311   arg1 = (Dali::KeyEvent *)jarg1;
27312   arg2 = (unsigned long)jarg2;
27313   if (arg1) (arg1)->time = arg2;
27314 }
27315
27316
27317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyEvent_time_get(void * jarg1) {
27318   unsigned long jresult ;
27319   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27320   unsigned long result;
27321
27322   arg1 = (Dali::KeyEvent *)jarg1;
27323   result = (unsigned long) ((arg1)->time);
27324   jresult = (unsigned long)result;
27325   return jresult;
27326 }
27327
27328
27329 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_state_set(void * jarg1, int jarg2) {
27330   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27331   Dali::KeyEvent::State arg2 ;
27332
27333   arg1 = (Dali::KeyEvent *)jarg1;
27334   arg2 = (Dali::KeyEvent::State)jarg2;
27335   if (arg1) (arg1)->state = arg2;
27336 }
27337
27338
27339 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_state_get(void * jarg1) {
27340   int jresult ;
27341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27342   Dali::KeyEvent::State result;
27343
27344   arg1 = (Dali::KeyEvent *)jarg1;
27345   result = (Dali::KeyEvent::State) ((arg1)->state);
27346   jresult = (int)result;
27347   return jresult;
27348 }
27349
27350
27351 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetector__SWIG_0() {
27352   void * jresult ;
27353   Dali::LongPressGestureDetector *result = 0 ;
27354
27355   {
27356     try {
27357       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27369       };
27370     }
27371   }
27372   jresult = (void *)result;
27373   return jresult;
27374 }
27375
27376
27377 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_0() {
27378   void * jresult ;
27379   Dali::LongPressGestureDetector result;
27380
27381   {
27382     try {
27383       result = Dali::LongPressGestureDetector::New();
27384     } catch (std::out_of_range& e) {
27385       {
27386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27387       };
27388     } catch (std::exception& e) {
27389       {
27390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27391       };
27392     } catch (...) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27395       };
27396     }
27397   }
27398   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27399   return jresult;
27400 }
27401
27402
27403 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27404   void * jresult ;
27405   unsigned int arg1 ;
27406   Dali::LongPressGestureDetector result;
27407
27408   arg1 = (unsigned int)jarg1;
27409   {
27410     try {
27411       result = Dali::LongPressGestureDetector::New(arg1);
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (...) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27423       };
27424     }
27425   }
27426   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27427   return jresult;
27428 }
27429
27430
27431 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27432   void * jresult ;
27433   unsigned int arg1 ;
27434   unsigned int arg2 ;
27435   Dali::LongPressGestureDetector result;
27436
27437   arg1 = (unsigned int)jarg1;
27438   arg2 = (unsigned int)jarg2;
27439   {
27440     try {
27441       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27442     } catch (std::out_of_range& e) {
27443       {
27444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27445       };
27446     } catch (std::exception& e) {
27447       {
27448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27449       };
27450     } catch (...) {
27451       {
27452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27453       };
27454     }
27455   }
27456   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27457   return jresult;
27458 }
27459
27460
27461 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_DownCast(void * jarg1) {
27462   void * jresult ;
27463   Dali::BaseHandle arg1 ;
27464   Dali::BaseHandle *argp1 ;
27465   Dali::LongPressGestureDetector result;
27466
27467   argp1 = (Dali::BaseHandle *)jarg1;
27468   if (!argp1) {
27469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27470     return 0;
27471   }
27472   arg1 = *argp1;
27473   {
27474     try {
27475       result = Dali::LongPressGestureDetector::DownCast(arg1);
27476     } catch (std::out_of_range& e) {
27477       {
27478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27479       };
27480     } catch (std::exception& e) {
27481       {
27482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27483       };
27484     } catch (...) {
27485       {
27486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27487       };
27488     }
27489   }
27490   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGestureDetector(void * jarg1) {
27496   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27497
27498   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27499   {
27500     try {
27501       delete arg1;
27502     } catch (std::out_of_range& e) {
27503       {
27504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27505       };
27506     } catch (std::exception& e) {
27507       {
27508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27509       };
27510     } catch (...) {
27511       {
27512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27513       };
27514     }
27515   }
27516 }
27517
27518
27519 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27520   void * jresult ;
27521   Dali::LongPressGestureDetector *arg1 = 0 ;
27522   Dali::LongPressGestureDetector *result = 0 ;
27523
27524   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27525   if (!arg1) {
27526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27527     return 0;
27528   }
27529   {
27530     try {
27531       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27532     } catch (std::out_of_range& e) {
27533       {
27534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27535       };
27536     } catch (std::exception& e) {
27537       {
27538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27539       };
27540     } catch (...) {
27541       {
27542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27543       };
27544     }
27545   }
27546   jresult = (void *)result;
27547   return jresult;
27548 }
27549
27550
27551 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27552   void * jresult ;
27553   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27554   Dali::LongPressGestureDetector *arg2 = 0 ;
27555   Dali::LongPressGestureDetector *result = 0 ;
27556
27557   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27558   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27559   if (!arg2) {
27560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27561     return 0;
27562   }
27563   {
27564     try {
27565       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27566     } catch (std::out_of_range& e) {
27567       {
27568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27569       };
27570     } catch (std::exception& e) {
27571       {
27572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27573       };
27574     } catch (...) {
27575       {
27576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27577       };
27578     }
27579   }
27580   jresult = (void *)result;
27581   return jresult;
27582 }
27583
27584
27585 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27586   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27587   unsigned int arg2 ;
27588
27589   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27590   arg2 = (unsigned int)jarg2;
27591   {
27592     try {
27593       (arg1)->SetTouchesRequired(arg2);
27594     } catch (std::out_of_range& e) {
27595       {
27596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27597       };
27598     } catch (std::exception& e) {
27599       {
27600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27601       };
27602     } catch (...) {
27603       {
27604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27605       };
27606     }
27607   }
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27612   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27613   unsigned int arg2 ;
27614   unsigned int arg3 ;
27615
27616   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27617   arg2 = (unsigned int)jarg2;
27618   arg3 = (unsigned int)jarg3;
27619   {
27620     try {
27621       (arg1)->SetTouchesRequired(arg2,arg3);
27622     } catch (std::out_of_range& e) {
27623       {
27624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27625       };
27626     } catch (std::exception& e) {
27627       {
27628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27629       };
27630     } catch (...) {
27631       {
27632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27633       };
27634     }
27635   }
27636 }
27637
27638
27639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27640   unsigned int jresult ;
27641   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27642   unsigned int result;
27643
27644   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27645   {
27646     try {
27647       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27648     } catch (std::out_of_range& e) {
27649       {
27650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27651       };
27652     } catch (std::exception& e) {
27653       {
27654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27655       };
27656     } catch (...) {
27657       {
27658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27659       };
27660     }
27661   }
27662   jresult = result;
27663   return jresult;
27664 }
27665
27666
27667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27668   unsigned int jresult ;
27669   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27670   unsigned int result;
27671
27672   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27673   {
27674     try {
27675       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27676     } catch (std::out_of_range& e) {
27677       {
27678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27679       };
27680     } catch (std::exception& e) {
27681       {
27682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27683       };
27684     } catch (...) {
27685       {
27686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27687       };
27688     }
27689   }
27690   jresult = result;
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27696   void * jresult ;
27697   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27698   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27699
27700   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27701   {
27702     try {
27703       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27704     } catch (std::out_of_range& e) {
27705       {
27706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27707       };
27708     } catch (std::exception& e) {
27709       {
27710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27711       };
27712     } catch (...) {
27713       {
27714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27715       };
27716     }
27717   }
27718   jresult = (void *)result;
27719   return jresult;
27720 }
27721
27722
27723 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGesture__SWIG_0(int jarg1) {
27724   void * jresult ;
27725   Dali::Gesture::State arg1 ;
27726   Dali::LongPressGesture *result = 0 ;
27727
27728   arg1 = (Dali::Gesture::State)jarg1;
27729   {
27730     try {
27731       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27732     } catch (std::out_of_range& e) {
27733       {
27734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27735       };
27736     } catch (std::exception& e) {
27737       {
27738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27739       };
27740     } catch (...) {
27741       {
27742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27743       };
27744     }
27745   }
27746   jresult = (void *)result;
27747   return jresult;
27748 }
27749
27750
27751 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGesture__SWIG_1(void * jarg1) {
27752   void * jresult ;
27753   Dali::LongPressGesture *arg1 = 0 ;
27754   Dali::LongPressGesture *result = 0 ;
27755
27756   arg1 = (Dali::LongPressGesture *)jarg1;
27757   if (!arg1) {
27758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27759     return 0;
27760   }
27761   {
27762     try {
27763       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (...) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27775       };
27776     }
27777   }
27778   jresult = (void *)result;
27779   return jresult;
27780 }
27781
27782
27783 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27784   void * jresult ;
27785   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27786   Dali::LongPressGesture *arg2 = 0 ;
27787   Dali::LongPressGesture *result = 0 ;
27788
27789   arg1 = (Dali::LongPressGesture *)jarg1;
27790   arg2 = (Dali::LongPressGesture *)jarg2;
27791   if (!arg2) {
27792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27793     return 0;
27794   }
27795   {
27796     try {
27797       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27798     } catch (std::out_of_range& e) {
27799       {
27800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27801       };
27802     } catch (std::exception& e) {
27803       {
27804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27805       };
27806     } catch (...) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27809       };
27810     }
27811   }
27812   jresult = (void *)result;
27813   return jresult;
27814 }
27815
27816
27817 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGesture(void * jarg1) {
27818   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27819
27820   arg1 = (Dali::LongPressGesture *)jarg1;
27821   {
27822     try {
27823       delete arg1;
27824     } catch (std::out_of_range& e) {
27825       {
27826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27827       };
27828     } catch (std::exception& e) {
27829       {
27830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27831       };
27832     } catch (...) {
27833       {
27834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27835       };
27836     }
27837   }
27838 }
27839
27840
27841 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
27842   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27843   unsigned int arg2 ;
27844
27845   arg1 = (Dali::LongPressGesture *)jarg1;
27846   arg2 = (unsigned int)jarg2;
27847   if (arg1) (arg1)->numberOfTouches = arg2;
27848 }
27849
27850
27851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGesture_numberOfTouches_get(void * jarg1) {
27852   unsigned int jresult ;
27853   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27854   unsigned int result;
27855
27856   arg1 = (Dali::LongPressGesture *)jarg1;
27857   result = (unsigned int) ((arg1)->numberOfTouches);
27858   jresult = result;
27859   return jresult;
27860 }
27861
27862
27863 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
27864   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27865   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27866
27867   arg1 = (Dali::LongPressGesture *)jarg1;
27868   arg2 = (Dali::Vector2 *)jarg2;
27869   if (arg1) (arg1)->screenPoint = *arg2;
27870 }
27871
27872
27873 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_screenPoint_get(void * jarg1) {
27874   void * jresult ;
27875   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27876   Dali::Vector2 *result = 0 ;
27877
27878   arg1 = (Dali::LongPressGesture *)jarg1;
27879   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
27880   jresult = (void *)result;
27881   return jresult;
27882 }
27883
27884
27885 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
27886   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27887   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27888
27889   arg1 = (Dali::LongPressGesture *)jarg1;
27890   arg2 = (Dali::Vector2 *)jarg2;
27891   if (arg1) (arg1)->localPoint = *arg2;
27892 }
27893
27894
27895 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_localPoint_get(void * jarg1) {
27896   void * jresult ;
27897   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27898   Dali::Vector2 *result = 0 ;
27899
27900   arg1 = (Dali::LongPressGesture *)jarg1;
27901   result = (Dali::Vector2 *)& ((arg1)->localPoint);
27902   jresult = (void *)result;
27903   return jresult;
27904 }
27905
27906
27907 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_WheelEvent__SWIG_0() {
27908   void * jresult ;
27909   Dali::WheelEvent *result = 0 ;
27910
27911   {
27912     try {
27913       result = (Dali::WheelEvent *)new Dali::WheelEvent();
27914     } catch (std::out_of_range& e) {
27915       {
27916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27917       };
27918     } catch (std::exception& e) {
27919       {
27920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27921       };
27922     } catch (...) {
27923       {
27924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27925       };
27926     }
27927   }
27928   jresult = (void *)result;
27929   return jresult;
27930 }
27931
27932
27933 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_WheelEvent__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
27934   void * jresult ;
27935   Dali::WheelEvent::Type arg1 ;
27936   int arg2 ;
27937   unsigned int arg3 ;
27938   Dali::Vector2 arg4 ;
27939   int arg5 ;
27940   unsigned int arg6 ;
27941   Dali::Vector2 *argp4 ;
27942   Dali::WheelEvent *result = 0 ;
27943
27944   arg1 = (Dali::WheelEvent::Type)jarg1;
27945   arg2 = (int)jarg2;
27946   arg3 = (unsigned int)jarg3;
27947   argp4 = (Dali::Vector2 *)jarg4;
27948   if (!argp4) {
27949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
27950     return 0;
27951   }
27952   arg4 = *argp4;
27953   arg5 = (int)jarg5;
27954   arg6 = (unsigned int)jarg6;
27955   {
27956     try {
27957       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
27958     } catch (std::out_of_range& e) {
27959       {
27960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (std::exception& e) {
27963       {
27964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27965       };
27966     } catch (...) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27969       };
27970     }
27971   }
27972   jresult = (void *)result;
27973   return jresult;
27974 }
27975
27976
27977 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_WheelEvent(void * jarg1) {
27978   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
27979
27980   arg1 = (Dali::WheelEvent *)jarg1;
27981   {
27982     try {
27983       delete arg1;
27984     } catch (std::out_of_range& e) {
27985       {
27986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27987       };
27988     } catch (std::exception& e) {
27989       {
27990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27991       };
27992     } catch (...) {
27993       {
27994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27995       };
27996     }
27997   }
27998 }
27999
28000
28001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsShiftModifier(void * jarg1) {
28002   unsigned int jresult ;
28003   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28004   bool result;
28005
28006   arg1 = (Dali::WheelEvent *)jarg1;
28007   {
28008     try {
28009       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28010     } catch (std::out_of_range& e) {
28011       {
28012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28013       };
28014     } catch (std::exception& e) {
28015       {
28016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28017       };
28018     } catch (...) {
28019       {
28020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28021       };
28022     }
28023   }
28024   jresult = result;
28025   return jresult;
28026 }
28027
28028
28029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsCtrlModifier(void * jarg1) {
28030   unsigned int jresult ;
28031   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28032   bool result;
28033
28034   arg1 = (Dali::WheelEvent *)jarg1;
28035   {
28036     try {
28037       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
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 = result;
28053   return jresult;
28054 }
28055
28056
28057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsAltModifier(void * jarg1) {
28058   unsigned int jresult ;
28059   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28060   bool result;
28061
28062   arg1 = (Dali::WheelEvent *)jarg1;
28063   {
28064     try {
28065       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28066     } catch (std::out_of_range& e) {
28067       {
28068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28069       };
28070     } catch (std::exception& e) {
28071       {
28072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28073       };
28074     } catch (...) {
28075       {
28076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28077       };
28078     }
28079   }
28080   jresult = result;
28081   return jresult;
28082 }
28083
28084
28085 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_type_set(void * jarg1, int jarg2) {
28086   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28087   Dali::WheelEvent::Type arg2 ;
28088
28089   arg1 = (Dali::WheelEvent *)jarg1;
28090   arg2 = (Dali::WheelEvent::Type)jarg2;
28091   if (arg1) (arg1)->type = arg2;
28092 }
28093
28094
28095 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_type_get(void * jarg1) {
28096   int jresult ;
28097   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28098   Dali::WheelEvent::Type result;
28099
28100   arg1 = (Dali::WheelEvent *)jarg1;
28101   result = (Dali::WheelEvent::Type) ((arg1)->type);
28102   jresult = (int)result;
28103   return jresult;
28104 }
28105
28106
28107 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_direction_set(void * jarg1, int jarg2) {
28108   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28109   int arg2 ;
28110
28111   arg1 = (Dali::WheelEvent *)jarg1;
28112   arg2 = (int)jarg2;
28113   if (arg1) (arg1)->direction = arg2;
28114 }
28115
28116
28117 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_direction_get(void * jarg1) {
28118   int jresult ;
28119   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28120   int result;
28121
28122   arg1 = (Dali::WheelEvent *)jarg1;
28123   result = (int) ((arg1)->direction);
28124   jresult = result;
28125   return jresult;
28126 }
28127
28128
28129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_modifiers_set(void * jarg1, unsigned int jarg2) {
28130   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28131   unsigned int arg2 ;
28132
28133   arg1 = (Dali::WheelEvent *)jarg1;
28134   arg2 = (unsigned int)jarg2;
28135   if (arg1) (arg1)->modifiers = arg2;
28136 }
28137
28138
28139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_modifiers_get(void * jarg1) {
28140   unsigned int jresult ;
28141   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28142   unsigned int result;
28143
28144   arg1 = (Dali::WheelEvent *)jarg1;
28145   result = (unsigned int) ((arg1)->modifiers);
28146   jresult = result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_point_set(void * jarg1, void * jarg2) {
28152   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28153   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28154
28155   arg1 = (Dali::WheelEvent *)jarg1;
28156   arg2 = (Dali::Vector2 *)jarg2;
28157   if (arg1) (arg1)->point = *arg2;
28158 }
28159
28160
28161 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_WheelEvent_point_get(void * jarg1) {
28162   void * jresult ;
28163   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28164   Dali::Vector2 *result = 0 ;
28165
28166   arg1 = (Dali::WheelEvent *)jarg1;
28167   result = (Dali::Vector2 *)& ((arg1)->point);
28168   jresult = (void *)result;
28169   return jresult;
28170 }
28171
28172
28173 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_z_set(void * jarg1, int jarg2) {
28174   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28175   int arg2 ;
28176
28177   arg1 = (Dali::WheelEvent *)jarg1;
28178   arg2 = (int)jarg2;
28179   if (arg1) (arg1)->z = arg2;
28180 }
28181
28182
28183 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_z_get(void * jarg1) {
28184   int jresult ;
28185   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28186   int result;
28187
28188   arg1 = (Dali::WheelEvent *)jarg1;
28189   result = (int) ((arg1)->z);
28190   jresult = result;
28191   return jresult;
28192 }
28193
28194
28195 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_timeStamp_set(void * jarg1, unsigned int jarg2) {
28196   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28197   unsigned int arg2 ;
28198
28199   arg1 = (Dali::WheelEvent *)jarg1;
28200   arg2 = (unsigned int)jarg2;
28201   if (arg1) (arg1)->timeStamp = arg2;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_timeStamp_get(void * jarg1) {
28206   unsigned int jresult ;
28207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28208   unsigned int result;
28209
28210   arg1 = (Dali::WheelEvent *)jarg1;
28211   result = (unsigned int) ((arg1)->timeStamp);
28212   jresult = result;
28213   return jresult;
28214 }
28215
28216
28217 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_get() {
28218   int jresult ;
28219   int result;
28220
28221   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28222   jresult = (int)result;
28223   return jresult;
28224 }
28225
28226
28227 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_X_get() {
28228   int jresult ;
28229   int result;
28230
28231   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28232   jresult = (int)result;
28233   return jresult;
28234 }
28235
28236
28237 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_Y_get() {
28238   int jresult ;
28239   int result;
28240
28241   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28242   jresult = (int)result;
28243   return jresult;
28244 }
28245
28246
28247 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_Z_get() {
28248   int jresult ;
28249   int result;
28250
28251   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28252   jresult = (int)result;
28253   return jresult;
28254 }
28255
28256
28257 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_get() {
28258   int jresult ;
28259   int result;
28260
28261   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28262   jresult = (int)result;
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_X_get() {
28268   int jresult ;
28269   int result;
28270
28271   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28272   jresult = (int)result;
28273   return jresult;
28274 }
28275
28276
28277 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_Y_get() {
28278   int jresult ;
28279   int result;
28280
28281   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28282   jresult = (int)result;
28283   return jresult;
28284 }
28285
28286
28287 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_Z_get() {
28288   int jresult ;
28289   int result;
28290
28291   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28292   jresult = (int)result;
28293   return jresult;
28294 }
28295
28296
28297 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_get() {
28298   int jresult ;
28299   int result;
28300
28301   result = (int)Dali::Actor::Property::SIZE;
28302   jresult = (int)result;
28303   return jresult;
28304 }
28305
28306
28307 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_WIDTH_get() {
28308   int jresult ;
28309   int result;
28310
28311   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28312   jresult = (int)result;
28313   return jresult;
28314 }
28315
28316
28317 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_HEIGHT_get() {
28318   int jresult ;
28319   int result;
28320
28321   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28322   jresult = (int)result;
28323   return jresult;
28324 }
28325
28326
28327 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_DEPTH_get() {
28328   int jresult ;
28329   int result;
28330
28331   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28332   jresult = (int)result;
28333   return jresult;
28334 }
28335
28336
28337 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_get() {
28338   int jresult ;
28339   int result;
28340
28341   result = (int)Dali::Actor::Property::POSITION;
28342   jresult = (int)result;
28343   return jresult;
28344 }
28345
28346
28347 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_X_get() {
28348   int jresult ;
28349   int result;
28350
28351   result = (int)Dali::Actor::Property::POSITION_X;
28352   jresult = (int)result;
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_Y_get() {
28358   int jresult ;
28359   int result;
28360
28361   result = (int)Dali::Actor::Property::POSITION_Y;
28362   jresult = (int)result;
28363   return jresult;
28364 }
28365
28366
28367 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_Z_get() {
28368   int jresult ;
28369   int result;
28370
28371   result = (int)Dali::Actor::Property::POSITION_Z;
28372   jresult = (int)result;
28373   return jresult;
28374 }
28375
28376
28377 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_get() {
28378   int jresult ;
28379   int result;
28380
28381   result = (int)Dali::Actor::Property::WORLD_POSITION;
28382   jresult = (int)result;
28383   return jresult;
28384 }
28385
28386
28387 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_X_get() {
28388   int jresult ;
28389   int result;
28390
28391   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28392   jresult = (int)result;
28393   return jresult;
28394 }
28395
28396
28397 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_Y_get() {
28398   int jresult ;
28399   int result;
28400
28401   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28402   jresult = (int)result;
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_Z_get() {
28408   int jresult ;
28409   int result;
28410
28411   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28412   jresult = (int)result;
28413   return jresult;
28414 }
28415
28416
28417 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ORIENTATION_get() {
28418   int jresult ;
28419   int result;
28420
28421   result = (int)Dali::Actor::Property::ORIENTATION;
28422   jresult = (int)result;
28423   return jresult;
28424 }
28425
28426
28427 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_ORIENTATION_get() {
28428   int jresult ;
28429   int result;
28430
28431   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28432   jresult = (int)result;
28433   return jresult;
28434 }
28435
28436
28437 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_get() {
28438   int jresult ;
28439   int result;
28440
28441   result = (int)Dali::Actor::Property::SCALE;
28442   jresult = (int)result;
28443   return jresult;
28444 }
28445
28446
28447 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_X_get() {
28448   int jresult ;
28449   int result;
28450
28451   result = (int)Dali::Actor::Property::SCALE_X;
28452   jresult = (int)result;
28453   return jresult;
28454 }
28455
28456
28457 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_Y_get() {
28458   int jresult ;
28459   int result;
28460
28461   result = (int)Dali::Actor::Property::SCALE_Y;
28462   jresult = (int)result;
28463   return jresult;
28464 }
28465
28466
28467 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_Z_get() {
28468   int jresult ;
28469   int result;
28470
28471   result = (int)Dali::Actor::Property::SCALE_Z;
28472   jresult = (int)result;
28473   return jresult;
28474 }
28475
28476
28477 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_SCALE_get() {
28478   int jresult ;
28479   int result;
28480
28481   result = (int)Dali::Actor::Property::WORLD_SCALE;
28482   jresult = (int)result;
28483   return jresult;
28484 }
28485
28486
28487 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_VISIBLE_get() {
28488   int jresult ;
28489   int result;
28490
28491   result = (int)Dali::Actor::Property::VISIBLE;
28492   jresult = (int)result;
28493   return jresult;
28494 }
28495
28496
28497 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_get() {
28498   int jresult ;
28499   int result;
28500
28501   result = (int)Dali::Actor::Property::COLOR;
28502   jresult = (int)result;
28503   return jresult;
28504 }
28505
28506
28507 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_RED_get() {
28508   int jresult ;
28509   int result;
28510
28511   result = (int)Dali::Actor::Property::COLOR_RED;
28512   jresult = (int)result;
28513   return jresult;
28514 }
28515
28516
28517 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_GREEN_get() {
28518   int jresult ;
28519   int result;
28520
28521   result = (int)Dali::Actor::Property::COLOR_GREEN;
28522   jresult = (int)result;
28523   return jresult;
28524 }
28525
28526
28527 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_BLUE_get() {
28528   int jresult ;
28529   int result;
28530
28531   result = (int)Dali::Actor::Property::COLOR_BLUE;
28532   jresult = (int)result;
28533   return jresult;
28534 }
28535
28536
28537 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_ALPHA_get() {
28538   int jresult ;
28539   int result;
28540
28541   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28542   jresult = (int)result;
28543   return jresult;
28544 }
28545
28546
28547 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_COLOR_get() {
28548   int jresult ;
28549   int result;
28550
28551   result = (int)Dali::Actor::Property::WORLD_COLOR;
28552   jresult = (int)result;
28553   return jresult;
28554 }
28555
28556
28557 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_MATRIX_get() {
28558   int jresult ;
28559   int result;
28560
28561   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28562   jresult = (int)result;
28563   return jresult;
28564 }
28565
28566
28567 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_NAME_get() {
28568   int jresult ;
28569   int result;
28570
28571   result = (int)Dali::Actor::Property::NAME;
28572   jresult = (int)result;
28573   return jresult;
28574 }
28575
28576
28577 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SENSITIVE_get() {
28578   int jresult ;
28579   int result;
28580
28581   result = (int)Dali::Actor::Property::SENSITIVE;
28582   jresult = (int)result;
28583   return jresult;
28584 }
28585
28586
28587 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_LEAVE_REQUIRED_get() {
28588   int jresult ;
28589   int result;
28590
28591   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28592   jresult = (int)result;
28593   return jresult;
28594 }
28595
28596
28597 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_ORIENTATION_get() {
28598   int jresult ;
28599   int result;
28600
28601   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28602   jresult = (int)result;
28603   return jresult;
28604 }
28605
28606
28607 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_SCALE_get() {
28608   int jresult ;
28609   int result;
28610
28611   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28612   jresult = (int)result;
28613   return jresult;
28614 }
28615
28616
28617 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_MODE_get() {
28618   int jresult ;
28619   int result;
28620
28621   result = (int)Dali::Actor::Property::COLOR_MODE;
28622   jresult = (int)result;
28623   return jresult;
28624 }
28625
28626
28627 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_INHERITANCE_get() {
28628   int jresult ;
28629   int result;
28630
28631   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28632   jresult = (int)result;
28633   return jresult;
28634 }
28635
28636
28637 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_DRAW_MODE_get() {
28638   int jresult ;
28639   int result;
28640
28641   result = (int)Dali::Actor::Property::DRAW_MODE;
28642   jresult = (int)result;
28643   return jresult;
28644 }
28645
28646
28647 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_MODE_FACTOR_get() {
28648   int jresult ;
28649   int result;
28650
28651   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28652   jresult = (int)result;
28653   return jresult;
28654 }
28655
28656
28657 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28658   int jresult ;
28659   int result;
28660
28661   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28662   jresult = (int)result;
28663   return jresult;
28664 }
28665
28666
28667 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28668   int jresult ;
28669   int result;
28670
28671   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28672   jresult = (int)result;
28673   return jresult;
28674 }
28675
28676
28677 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_SCALE_POLICY_get() {
28678   int jresult ;
28679   int result;
28680
28681   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28682   jresult = (int)result;
28683   return jresult;
28684 }
28685
28686
28687 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28688   int jresult ;
28689   int result;
28690
28691   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28692   jresult = (int)result;
28693   return jresult;
28694 }
28695
28696
28697 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28698   int jresult ;
28699   int result;
28700
28701   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28702   jresult = (int)result;
28703   return jresult;
28704 }
28705
28706
28707 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PADDING_get() {
28708   int jresult ;
28709   int result;
28710
28711   result = (int)Dali::Actor::Property::PADDING;
28712   jresult = (int)result;
28713   return jresult;
28714 }
28715
28716
28717 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_MINIMUM_SIZE_get() {
28718   int jresult ;
28719   int result;
28720
28721   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28722   jresult = (int)result;
28723   return jresult;
28724 }
28725
28726
28727 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_MAXIMUM_SIZE_get() {
28728   int jresult ;
28729   int result;
28730
28731   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28732   jresult = (int)result;
28733   return jresult;
28734 }
28735
28736
28737 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_POSITION_get() {
28738   int jresult ;
28739   int result;
28740
28741   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28742   jresult = (int)result;
28743   return jresult;
28744 }
28745
28746
28747 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_CLIPPING_MODE_get() {
28748   int jresult ;
28749   int result;
28750
28751   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28752   jresult = (int)result;
28753   return jresult;
28754 }
28755
28756
28757 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor_Property() {
28758   void * jresult ;
28759   Dali::Actor::Property *result = 0 ;
28760
28761   {
28762     try {
28763       result = (Dali::Actor::Property *)new Dali::Actor::Property();
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
28783 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Actor_Property(void * jarg1) {
28784   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28785
28786   arg1 = (Dali::Actor::Property *)jarg1;
28787   {
28788     try {
28789       delete arg1;
28790     } catch (std::out_of_range& e) {
28791       {
28792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28793       };
28794     } catch (std::exception& e) {
28795       {
28796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28797       };
28798     } catch (...) {
28799       {
28800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28801       };
28802     }
28803   }
28804 }
28805
28806
28807 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor__SWIG_0() {
28808   void * jresult ;
28809   Dali::Actor *result = 0 ;
28810
28811   {
28812     try {
28813       result = (Dali::Actor *)new Dali::Actor();
28814     } catch (std::out_of_range& e) {
28815       {
28816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28817       };
28818     } catch (std::exception& e) {
28819       {
28820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28821       };
28822     } catch (...) {
28823       {
28824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28825       };
28826     }
28827   }
28828   jresult = (void *)result;
28829   return jresult;
28830 }
28831
28832
28833 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_New() {
28834   void * jresult ;
28835   Dali::Actor result;
28836
28837   {
28838     try {
28839       result = Dali::Actor::New();
28840     } catch (std::out_of_range& e) {
28841       {
28842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28843       };
28844     } catch (std::exception& e) {
28845       {
28846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28847       };
28848     } catch (...) {
28849       {
28850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28851       };
28852     }
28853   }
28854   jresult = new Dali::Actor((const Dali::Actor &)result);
28855   return jresult;
28856 }
28857
28858
28859 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_DownCast(void * jarg1) {
28860   void * jresult ;
28861   Dali::BaseHandle arg1 ;
28862   Dali::BaseHandle *argp1 ;
28863   Dali::Actor result;
28864
28865   argp1 = (Dali::BaseHandle *)jarg1;
28866   if (!argp1) {
28867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28868     return 0;
28869   }
28870   arg1 = *argp1;
28871   {
28872     try {
28873       result = Dali::Actor::DownCast(arg1);
28874     } catch (std::out_of_range& e) {
28875       {
28876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28877       };
28878     } catch (std::exception& e) {
28879       {
28880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28881       };
28882     } catch (...) {
28883       {
28884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28885       };
28886     }
28887   }
28888   jresult = new Dali::Actor((const Dali::Actor &)result);
28889   return jresult;
28890 }
28891
28892
28893 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Actor(void * jarg1) {
28894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28895
28896   arg1 = (Dali::Actor *)jarg1;
28897   {
28898     try {
28899       delete arg1;
28900     } catch (std::out_of_range& e) {
28901       {
28902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28903       };
28904     } catch (std::exception& e) {
28905       {
28906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28907       };
28908     } catch (...) {
28909       {
28910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28911       };
28912     }
28913   }
28914 }
28915
28916
28917 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor__SWIG_1(void * jarg1) {
28918   void * jresult ;
28919   Dali::Actor *arg1 = 0 ;
28920   Dali::Actor *result = 0 ;
28921
28922   arg1 = (Dali::Actor *)jarg1;
28923   if (!arg1) {
28924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28925     return 0;
28926   }
28927   {
28928     try {
28929       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
28930     } catch (std::out_of_range& e) {
28931       {
28932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28933       };
28934     } catch (std::exception& e) {
28935       {
28936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28937       };
28938     } catch (...) {
28939       {
28940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28941       };
28942     }
28943   }
28944   jresult = (void *)result;
28945   return jresult;
28946 }
28947
28948
28949 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_Assign(void * jarg1, void * jarg2) {
28950   void * jresult ;
28951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28952   Dali::Actor *arg2 = 0 ;
28953   Dali::Actor *result = 0 ;
28954
28955   arg1 = (Dali::Actor *)jarg1;
28956   arg2 = (Dali::Actor *)jarg2;
28957   if (!arg2) {
28958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28959     return 0;
28960   }
28961   {
28962     try {
28963       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
28964     } catch (std::out_of_range& e) {
28965       {
28966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28967       };
28968     } catch (std::exception& e) {
28969       {
28970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28971       };
28972     } catch (...) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28975       };
28976     }
28977   }
28978   jresult = (void *)result;
28979   return jresult;
28980 }
28981
28982
28983 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Actor_GetName(void * jarg1) {
28984   char * jresult ;
28985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28986   std::string *result = 0 ;
28987
28988   arg1 = (Dali::Actor *)jarg1;
28989   {
28990     try {
28991       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
28992     } catch (std::out_of_range& e) {
28993       {
28994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28995       };
28996     } catch (std::exception& e) {
28997       {
28998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28999       };
29000     } catch (...) {
29001       {
29002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29003       };
29004     }
29005   }
29006   jresult = SWIG_csharp_string_callback(result->c_str());
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetName(void * jarg1, char * jarg2) {
29012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29013   std::string *arg2 = 0 ;
29014
29015   arg1 = (Dali::Actor *)jarg1;
29016   if (!jarg2) {
29017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29018     return ;
29019   }
29020   std::string arg2_str(jarg2);
29021   arg2 = &arg2_str;
29022   {
29023     try {
29024       (arg1)->SetName((std::string const &)*arg2);
29025     } catch (std::out_of_range& e) {
29026       {
29027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29028       };
29029     } catch (std::exception& e) {
29030       {
29031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29032       };
29033     } catch (...) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29036       };
29037     }
29038   }
29039
29040   //argout typemap for const std::string&
29041
29042 }
29043
29044
29045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetId(void * jarg1) {
29046   unsigned int jresult ;
29047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29048   unsigned int result;
29049
29050   arg1 = (Dali::Actor *)jarg1;
29051   {
29052     try {
29053       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29061       };
29062     } catch (...) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29065       };
29066     }
29067   }
29068   jresult = result;
29069   return jresult;
29070 }
29071
29072
29073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsRoot(void * jarg1) {
29074   unsigned int jresult ;
29075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29076   bool result;
29077
29078   arg1 = (Dali::Actor *)jarg1;
29079   {
29080     try {
29081       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29082     } catch (std::out_of_range& e) {
29083       {
29084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29085       };
29086     } catch (std::exception& e) {
29087       {
29088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29089       };
29090     } catch (...) {
29091       {
29092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29093       };
29094     }
29095   }
29096   jresult = result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_OnStage(void * jarg1) {
29102   unsigned int jresult ;
29103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29104   bool result;
29105
29106   arg1 = (Dali::Actor *)jarg1;
29107   {
29108     try {
29109       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29110     } catch (std::out_of_range& e) {
29111       {
29112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29113       };
29114     } catch (std::exception& e) {
29115       {
29116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29117       };
29118     } catch (...) {
29119       {
29120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29121       };
29122     }
29123   }
29124   jresult = result;
29125   return jresult;
29126 }
29127
29128
29129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsLayer(void * jarg1) {
29130   unsigned int jresult ;
29131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29132   bool result;
29133
29134   arg1 = (Dali::Actor *)jarg1;
29135   {
29136     try {
29137       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29138     } catch (std::out_of_range& e) {
29139       {
29140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29141       };
29142     } catch (std::exception& e) {
29143       {
29144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29145       };
29146     } catch (...) {
29147       {
29148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29149       };
29150     }
29151   }
29152   jresult = result;
29153   return jresult;
29154 }
29155
29156
29157 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetLayer(void * jarg1) {
29158   void * jresult ;
29159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29160   Dali::Layer result;
29161
29162   arg1 = (Dali::Actor *)jarg1;
29163   {
29164     try {
29165       result = (arg1)->GetLayer();
29166     } catch (std::out_of_range& e) {
29167       {
29168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29169       };
29170     } catch (std::exception& e) {
29171       {
29172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29173       };
29174     } catch (...) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29177       };
29178     }
29179   }
29180   jresult = new Dali::Layer((const Dali::Layer &)result);
29181   return jresult;
29182 }
29183
29184
29185 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Add(void * jarg1, void * jarg2) {
29186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29187   Dali::Actor arg2 ;
29188   Dali::Actor *argp2 ;
29189
29190   arg1 = (Dali::Actor *)jarg1;
29191   argp2 = (Dali::Actor *)jarg2;
29192   if (!argp2) {
29193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29194     return ;
29195   }
29196   arg2 = *argp2;
29197   {
29198     try {
29199       (arg1)->Add(arg2);
29200     } catch (std::out_of_range& e) {
29201       {
29202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29203       };
29204     } catch (std::exception& e) {
29205       {
29206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29207       };
29208     } catch (...) {
29209       {
29210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29211       };
29212     }
29213   }
29214 }
29215
29216
29217 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Remove(void * jarg1, void * jarg2) {
29218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29219   Dali::Actor arg2 ;
29220   Dali::Actor *argp2 ;
29221
29222   arg1 = (Dali::Actor *)jarg1;
29223   argp2 = (Dali::Actor *)jarg2;
29224   if (!argp2) {
29225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29226     return ;
29227   }
29228   arg2 = *argp2;
29229   {
29230     try {
29231       (arg1)->Remove(arg2);
29232     } catch (std::out_of_range& e) {
29233       {
29234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29235       };
29236     } catch (std::exception& e) {
29237       {
29238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29239       };
29240     } catch (...) {
29241       {
29242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29243       };
29244     }
29245   }
29246 }
29247
29248
29249 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Unparent(void * jarg1) {
29250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29251
29252   arg1 = (Dali::Actor *)jarg1;
29253   {
29254     try {
29255       (arg1)->Unparent();
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29263       };
29264     } catch (...) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29267       };
29268     }
29269   }
29270 }
29271
29272
29273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetChildCount(void * jarg1) {
29274   unsigned int jresult ;
29275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29276   unsigned int result;
29277
29278   arg1 = (Dali::Actor *)jarg1;
29279   {
29280     try {
29281       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29282     } catch (std::out_of_range& e) {
29283       {
29284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29285       };
29286     } catch (std::exception& e) {
29287       {
29288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29289       };
29290     } catch (...) {
29291       {
29292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29293       };
29294     }
29295   }
29296   jresult = result;
29297   return jresult;
29298 }
29299
29300
29301 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29302   void * jresult ;
29303   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29304   unsigned int arg2 ;
29305   Dali::Actor result;
29306
29307   arg1 = (Dali::Actor *)jarg1;
29308   arg2 = (unsigned int)jarg2;
29309   {
29310     try {
29311       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29312     } catch (std::out_of_range& e) {
29313       {
29314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29315       };
29316     } catch (std::exception& e) {
29317       {
29318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29319       };
29320     } catch (...) {
29321       {
29322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29323       };
29324     }
29325   }
29326   jresult = new Dali::Actor((const Dali::Actor &)result);
29327   return jresult;
29328 }
29329
29330
29331 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_FindChildByName(void * jarg1, char * jarg2) {
29332   void * jresult ;
29333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29334   std::string *arg2 = 0 ;
29335   Dali::Actor result;
29336
29337   arg1 = (Dali::Actor *)jarg1;
29338   if (!jarg2) {
29339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29340     return 0;
29341   }
29342   std::string arg2_str(jarg2);
29343   arg2 = &arg2_str;
29344   {
29345     try {
29346       result = (arg1)->FindChildByName((std::string const &)*arg2);
29347     } catch (std::out_of_range& e) {
29348       {
29349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29350       };
29351     } catch (std::exception& e) {
29352       {
29353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29354       };
29355     } catch (...) {
29356       {
29357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29358       };
29359     }
29360   }
29361   jresult = new Dali::Actor((const Dali::Actor &)result);
29362
29363   //argout typemap for const std::string&
29364
29365   return jresult;
29366 }
29367
29368
29369 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29370   void * jresult ;
29371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29372   unsigned int arg2 ;
29373   Dali::Actor result;
29374
29375   arg1 = (Dali::Actor *)jarg1;
29376   arg2 = (unsigned int)jarg2;
29377   {
29378     try {
29379       result = (arg1)->FindChildById(arg2);
29380     } catch (std::out_of_range& e) {
29381       {
29382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29383       };
29384     } catch (std::exception& e) {
29385       {
29386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (...) {
29389       {
29390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29391       };
29392     }
29393   }
29394   jresult = new Dali::Actor((const Dali::Actor &)result);
29395   return jresult;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetParent(void * jarg1) {
29400   void * jresult ;
29401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29402   Dali::Actor result;
29403
29404   arg1 = (Dali::Actor *)jarg1;
29405   {
29406     try {
29407       result = ((Dali::Actor const *)arg1)->GetParent();
29408     } catch (std::out_of_range& e) {
29409       {
29410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29411       };
29412     } catch (std::exception& e) {
29413       {
29414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29415       };
29416     } catch (...) {
29417       {
29418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29419       };
29420     }
29421   }
29422   jresult = new Dali::Actor((const Dali::Actor &)result);
29423   return jresult;
29424 }
29425
29426
29427 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29428   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29429   Dali::Vector3 *arg2 = 0 ;
29430
29431   arg1 = (Dali::Actor *)jarg1;
29432   arg2 = (Dali::Vector3 *)jarg2;
29433   if (!arg2) {
29434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29435     return ;
29436   }
29437   {
29438     try {
29439       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29440     } catch (std::out_of_range& e) {
29441       {
29442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29443       };
29444     } catch (std::exception& e) {
29445       {
29446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29447       };
29448     } catch (...) {
29449       {
29450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29451       };
29452     }
29453   }
29454 }
29455
29456
29457 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentParentOrigin(void * jarg1) {
29458   void * jresult ;
29459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29460   Dali::Vector3 result;
29461
29462   arg1 = (Dali::Actor *)jarg1;
29463   {
29464     try {
29465       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29466     } catch (std::out_of_range& e) {
29467       {
29468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (std::exception& e) {
29471       {
29472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (...) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29477       };
29478     }
29479   }
29480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29481   return jresult;
29482 }
29483
29484
29485 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29487   Dali::Vector3 *arg2 = 0 ;
29488
29489   arg1 = (Dali::Actor *)jarg1;
29490   arg2 = (Dali::Vector3 *)jarg2;
29491   if (!arg2) {
29492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29493     return ;
29494   }
29495   {
29496     try {
29497       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29498     } catch (std::out_of_range& e) {
29499       {
29500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29501       };
29502     } catch (std::exception& e) {
29503       {
29504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29505       };
29506     } catch (...) {
29507       {
29508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29509       };
29510     }
29511   }
29512 }
29513
29514
29515 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentAnchorPoint(void * jarg1) {
29516   void * jresult ;
29517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29518   Dali::Vector3 result;
29519
29520   arg1 = (Dali::Actor *)jarg1;
29521   {
29522     try {
29523       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29524     } catch (std::out_of_range& e) {
29525       {
29526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29527       };
29528     } catch (std::exception& e) {
29529       {
29530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29531       };
29532     } catch (...) {
29533       {
29534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29535       };
29536     }
29537   }
29538   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29539   return jresult;
29540 }
29541
29542
29543 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29545   float arg2 ;
29546   float arg3 ;
29547
29548   arg1 = (Dali::Actor *)jarg1;
29549   arg2 = (float)jarg2;
29550   arg3 = (float)jarg3;
29551   {
29552     try {
29553       (arg1)->SetSize(arg2,arg3);
29554     } catch (std::out_of_range& e) {
29555       {
29556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29557       };
29558     } catch (std::exception& e) {
29559       {
29560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29561       };
29562     } catch (...) {
29563       {
29564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29565       };
29566     }
29567   }
29568 }
29569
29570
29571 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29573   float arg2 ;
29574   float arg3 ;
29575   float arg4 ;
29576
29577   arg1 = (Dali::Actor *)jarg1;
29578   arg2 = (float)jarg2;
29579   arg3 = (float)jarg3;
29580   arg4 = (float)jarg4;
29581   {
29582     try {
29583       (arg1)->SetSize(arg2,arg3,arg4);
29584     } catch (std::out_of_range& e) {
29585       {
29586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29587       };
29588     } catch (std::exception& e) {
29589       {
29590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29591       };
29592     } catch (...) {
29593       {
29594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29595       };
29596     }
29597   }
29598 }
29599
29600
29601 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29602   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29603   Dali::Vector2 *arg2 = 0 ;
29604
29605   arg1 = (Dali::Actor *)jarg1;
29606   arg2 = (Dali::Vector2 *)jarg2;
29607   if (!arg2) {
29608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29609     return ;
29610   }
29611   {
29612     try {
29613       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29614     } catch (std::out_of_range& e) {
29615       {
29616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29617       };
29618     } catch (std::exception& e) {
29619       {
29620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29621       };
29622     } catch (...) {
29623       {
29624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29625       };
29626     }
29627   }
29628 }
29629
29630
29631 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29633   Dali::Vector3 *arg2 = 0 ;
29634
29635   arg1 = (Dali::Actor *)jarg1;
29636   arg2 = (Dali::Vector3 *)jarg2;
29637   if (!arg2) {
29638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29639     return ;
29640   }
29641   {
29642     try {
29643       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29644     } catch (std::out_of_range& e) {
29645       {
29646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29647       };
29648     } catch (std::exception& e) {
29649       {
29650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29651       };
29652     } catch (...) {
29653       {
29654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29655       };
29656     }
29657   }
29658 }
29659
29660
29661 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetTargetSize(void * jarg1) {
29662   void * jresult ;
29663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29664   Dali::Vector3 result;
29665
29666   arg1 = (Dali::Actor *)jarg1;
29667   {
29668     try {
29669       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29670     } catch (std::out_of_range& e) {
29671       {
29672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29673       };
29674     } catch (std::exception& e) {
29675       {
29676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29677       };
29678     } catch (...) {
29679       {
29680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29681       };
29682     }
29683   }
29684   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29685   return jresult;
29686 }
29687
29688
29689 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentSize(void * jarg1) {
29690   void * jresult ;
29691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29692   Dali::Vector3 result;
29693
29694   arg1 = (Dali::Actor *)jarg1;
29695   {
29696     try {
29697       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29698     } catch (std::out_of_range& e) {
29699       {
29700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29701       };
29702     } catch (std::exception& e) {
29703       {
29704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (...) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29709       };
29710     }
29711   }
29712   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29713   return jresult;
29714 }
29715
29716
29717 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetNaturalSize(void * jarg1) {
29718   void * jresult ;
29719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29720   Dali::Vector3 result;
29721
29722   arg1 = (Dali::Actor *)jarg1;
29723   {
29724     try {
29725       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29726     } catch (std::out_of_range& e) {
29727       {
29728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29729       };
29730     } catch (std::exception& e) {
29731       {
29732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29733       };
29734     } catch (...) {
29735       {
29736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29737       };
29738     }
29739   }
29740   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29741   return jresult;
29742 }
29743
29744
29745 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29747   float arg2 ;
29748   float arg3 ;
29749
29750   arg1 = (Dali::Actor *)jarg1;
29751   arg2 = (float)jarg2;
29752   arg3 = (float)jarg3;
29753   {
29754     try {
29755       (arg1)->SetPosition(arg2,arg3);
29756     } catch (std::out_of_range& e) {
29757       {
29758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29759       };
29760     } catch (std::exception& e) {
29761       {
29762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29763       };
29764     } catch (...) {
29765       {
29766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29767       };
29768     }
29769   }
29770 }
29771
29772
29773 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29775   float arg2 ;
29776   float arg3 ;
29777   float arg4 ;
29778
29779   arg1 = (Dali::Actor *)jarg1;
29780   arg2 = (float)jarg2;
29781   arg3 = (float)jarg3;
29782   arg4 = (float)jarg4;
29783   {
29784     try {
29785       (arg1)->SetPosition(arg2,arg3,arg4);
29786     } catch (std::out_of_range& e) {
29787       {
29788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29789       };
29790     } catch (std::exception& e) {
29791       {
29792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29793       };
29794     } catch (...) {
29795       {
29796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29797       };
29798     }
29799   }
29800 }
29801
29802
29803 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29805   Dali::Vector3 *arg2 = 0 ;
29806
29807   arg1 = (Dali::Actor *)jarg1;
29808   arg2 = (Dali::Vector3 *)jarg2;
29809   if (!arg2) {
29810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29811     return ;
29812   }
29813   {
29814     try {
29815       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
29816     } catch (std::out_of_range& e) {
29817       {
29818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29819       };
29820     } catch (std::exception& e) {
29821       {
29822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29823       };
29824     } catch (...) {
29825       {
29826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29827       };
29828     }
29829   }
29830 }
29831
29832
29833 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetX(void * jarg1, float jarg2) {
29834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29835   float arg2 ;
29836
29837   arg1 = (Dali::Actor *)jarg1;
29838   arg2 = (float)jarg2;
29839   {
29840     try {
29841       (arg1)->SetX(arg2);
29842     } catch (std::out_of_range& e) {
29843       {
29844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29845       };
29846     } catch (std::exception& e) {
29847       {
29848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29849       };
29850     } catch (...) {
29851       {
29852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29853       };
29854     }
29855   }
29856 }
29857
29858
29859 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetY(void * jarg1, float jarg2) {
29860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29861   float arg2 ;
29862
29863   arg1 = (Dali::Actor *)jarg1;
29864   arg2 = (float)jarg2;
29865   {
29866     try {
29867       (arg1)->SetY(arg2);
29868     } catch (std::out_of_range& e) {
29869       {
29870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29871       };
29872     } catch (std::exception& e) {
29873       {
29874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29875       };
29876     } catch (...) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29879       };
29880     }
29881   }
29882 }
29883
29884
29885 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetZ(void * jarg1, float jarg2) {
29886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29887   float arg2 ;
29888
29889   arg1 = (Dali::Actor *)jarg1;
29890   arg2 = (float)jarg2;
29891   {
29892     try {
29893       (arg1)->SetZ(arg2);
29894     } catch (std::out_of_range& e) {
29895       {
29896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29897       };
29898     } catch (std::exception& e) {
29899       {
29900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29901       };
29902     } catch (...) {
29903       {
29904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29905       };
29906     }
29907   }
29908 }
29909
29910
29911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_TranslateBy(void * jarg1, void * jarg2) {
29912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29913   Dali::Vector3 *arg2 = 0 ;
29914
29915   arg1 = (Dali::Actor *)jarg1;
29916   arg2 = (Dali::Vector3 *)jarg2;
29917   if (!arg2) {
29918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29919     return ;
29920   }
29921   {
29922     try {
29923       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
29924     } catch (std::out_of_range& e) {
29925       {
29926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29927       };
29928     } catch (std::exception& e) {
29929       {
29930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29931       };
29932     } catch (...) {
29933       {
29934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29935       };
29936     }
29937   }
29938 }
29939
29940
29941 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentPosition(void * jarg1) {
29942   void * jresult ;
29943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29944   Dali::Vector3 result;
29945
29946   arg1 = (Dali::Actor *)jarg1;
29947   {
29948     try {
29949       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
29950     } catch (std::out_of_range& e) {
29951       {
29952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (std::exception& e) {
29955       {
29956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29957       };
29958     } catch (...) {
29959       {
29960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29961       };
29962     }
29963   }
29964   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29965   return jresult;
29966 }
29967
29968
29969 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldPosition(void * jarg1) {
29970   void * jresult ;
29971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29972   Dali::Vector3 result;
29973
29974   arg1 = (Dali::Actor *)jarg1;
29975   {
29976     try {
29977       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
29978     } catch (std::out_of_range& e) {
29979       {
29980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (std::exception& e) {
29983       {
29984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29985       };
29986     } catch (...) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29989       };
29990     }
29991   }
29992   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29993   return jresult;
29994 }
29995
29996
29997 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
29998   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29999   bool arg2 ;
30000
30001   arg1 = (Dali::Actor *)jarg1;
30002   arg2 = jarg2 ? true : false;
30003   {
30004     try {
30005       (arg1)->SetInheritPosition(arg2);
30006     } catch (std::out_of_range& e) {
30007       {
30008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30009       };
30010     } catch (std::exception& e) {
30011       {
30012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30013       };
30014     } catch (...) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30017       };
30018     }
30019   }
30020 }
30021
30022
30023 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetPositionInheritanceMode(void * jarg1) {
30024   int jresult ;
30025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30026   Dali::PositionInheritanceMode result;
30027
30028   arg1 = (Dali::Actor *)jarg1;
30029   {
30030     try {
30031       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30032     } catch (std::out_of_range& e) {
30033       {
30034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30035       };
30036     } catch (std::exception& e) {
30037       {
30038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30039       };
30040     } catch (...) {
30041       {
30042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30043       };
30044     }
30045   }
30046   jresult = (int)result;
30047   return jresult;
30048 }
30049
30050
30051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsPositionInherited(void * jarg1) {
30052   unsigned int jresult ;
30053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30054   bool result;
30055
30056   arg1 = (Dali::Actor *)jarg1;
30057   {
30058     try {
30059       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30060     } catch (std::out_of_range& e) {
30061       {
30062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30063       };
30064     } catch (std::exception& e) {
30065       {
30066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30067       };
30068     } catch (...) {
30069       {
30070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30071       };
30072     }
30073   }
30074   jresult = result;
30075   return jresult;
30076 }
30077
30078
30079 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30081   Dali::Degree *arg2 = 0 ;
30082   Dali::Vector3 *arg3 = 0 ;
30083
30084   arg1 = (Dali::Actor *)jarg1;
30085   arg2 = (Dali::Degree *)jarg2;
30086   if (!arg2) {
30087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30088     return ;
30089   }
30090   arg3 = (Dali::Vector3 *)jarg3;
30091   if (!arg3) {
30092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30093     return ;
30094   }
30095   {
30096     try {
30097       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30098     } catch (std::out_of_range& e) {
30099       {
30100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30101       };
30102     } catch (std::exception& e) {
30103       {
30104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30105       };
30106     } catch (...) {
30107       {
30108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30109       };
30110     }
30111   }
30112 }
30113
30114
30115 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30117   Dali::Radian *arg2 = 0 ;
30118   Dali::Vector3 *arg3 = 0 ;
30119
30120   arg1 = (Dali::Actor *)jarg1;
30121   arg2 = (Dali::Radian *)jarg2;
30122   if (!arg2) {
30123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30124     return ;
30125   }
30126   arg3 = (Dali::Vector3 *)jarg3;
30127   if (!arg3) {
30128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30129     return ;
30130   }
30131   {
30132     try {
30133       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30134     } catch (std::out_of_range& e) {
30135       {
30136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30137       };
30138     } catch (std::exception& e) {
30139       {
30140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30141       };
30142     } catch (...) {
30143       {
30144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30145       };
30146     }
30147   }
30148 }
30149
30150
30151 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30153   Dali::Quaternion *arg2 = 0 ;
30154
30155   arg1 = (Dali::Actor *)jarg1;
30156   arg2 = (Dali::Quaternion *)jarg2;
30157   if (!arg2) {
30158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30159     return ;
30160   }
30161   {
30162     try {
30163       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30164     } catch (std::out_of_range& e) {
30165       {
30166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30167       };
30168     } catch (std::exception& e) {
30169       {
30170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30171       };
30172     } catch (...) {
30173       {
30174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30175       };
30176     }
30177   }
30178 }
30179
30180
30181 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30183   Dali::Degree *arg2 = 0 ;
30184   Dali::Vector3 *arg3 = 0 ;
30185
30186   arg1 = (Dali::Actor *)jarg1;
30187   arg2 = (Dali::Degree *)jarg2;
30188   if (!arg2) {
30189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30190     return ;
30191   }
30192   arg3 = (Dali::Vector3 *)jarg3;
30193   if (!arg3) {
30194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30195     return ;
30196   }
30197   {
30198     try {
30199       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30200     } catch (std::out_of_range& e) {
30201       {
30202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30203       };
30204     } catch (std::exception& e) {
30205       {
30206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30207       };
30208     } catch (...) {
30209       {
30210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30211       };
30212     }
30213   }
30214 }
30215
30216
30217 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30219   Dali::Radian *arg2 = 0 ;
30220   Dali::Vector3 *arg3 = 0 ;
30221
30222   arg1 = (Dali::Actor *)jarg1;
30223   arg2 = (Dali::Radian *)jarg2;
30224   if (!arg2) {
30225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30226     return ;
30227   }
30228   arg3 = (Dali::Vector3 *)jarg3;
30229   if (!arg3) {
30230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30231     return ;
30232   }
30233   {
30234     try {
30235       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30236     } catch (std::out_of_range& e) {
30237       {
30238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30239       };
30240     } catch (std::exception& e) {
30241       {
30242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30243       };
30244     } catch (...) {
30245       {
30246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30247       };
30248     }
30249   }
30250 }
30251
30252
30253 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30255   Dali::Quaternion *arg2 = 0 ;
30256
30257   arg1 = (Dali::Actor *)jarg1;
30258   arg2 = (Dali::Quaternion *)jarg2;
30259   if (!arg2) {
30260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30261     return ;
30262   }
30263   {
30264     try {
30265       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30266     } catch (std::out_of_range& e) {
30267       {
30268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30269       };
30270     } catch (std::exception& e) {
30271       {
30272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30273       };
30274     } catch (...) {
30275       {
30276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30277       };
30278     }
30279   }
30280 }
30281
30282
30283 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentOrientation(void * jarg1) {
30284   void * jresult ;
30285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30286   Dali::Quaternion result;
30287
30288   arg1 = (Dali::Actor *)jarg1;
30289   {
30290     try {
30291       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (...) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30303       };
30304     }
30305   }
30306   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30307   return jresult;
30308 }
30309
30310
30311 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30313   bool arg2 ;
30314
30315   arg1 = (Dali::Actor *)jarg1;
30316   arg2 = jarg2 ? true : false;
30317   {
30318     try {
30319       (arg1)->SetInheritOrientation(arg2);
30320     } catch (std::out_of_range& e) {
30321       {
30322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30323       };
30324     } catch (std::exception& e) {
30325       {
30326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (...) {
30329       {
30330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30331       };
30332     }
30333   }
30334 }
30335
30336
30337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsOrientationInherited(void * jarg1) {
30338   unsigned int jresult ;
30339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30340   bool result;
30341
30342   arg1 = (Dali::Actor *)jarg1;
30343   {
30344     try {
30345       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (...) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30357       };
30358     }
30359   }
30360   jresult = result;
30361   return jresult;
30362 }
30363
30364
30365 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldOrientation(void * jarg1) {
30366   void * jresult ;
30367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30368   Dali::Quaternion result;
30369
30370   arg1 = (Dali::Actor *)jarg1;
30371   {
30372     try {
30373       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30374     } catch (std::out_of_range& e) {
30375       {
30376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30377       };
30378     } catch (std::exception& e) {
30379       {
30380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30381       };
30382     } catch (...) {
30383       {
30384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30385       };
30386     }
30387   }
30388   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30389   return jresult;
30390 }
30391
30392
30393 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30395   float arg2 ;
30396
30397   arg1 = (Dali::Actor *)jarg1;
30398   arg2 = (float)jarg2;
30399   {
30400     try {
30401       (arg1)->SetScale(arg2);
30402     } catch (std::out_of_range& e) {
30403       {
30404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30405       };
30406     } catch (std::exception& e) {
30407       {
30408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30409       };
30410     } catch (...) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30413       };
30414     }
30415   }
30416 }
30417
30418
30419 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30421   float arg2 ;
30422   float arg3 ;
30423   float arg4 ;
30424
30425   arg1 = (Dali::Actor *)jarg1;
30426   arg2 = (float)jarg2;
30427   arg3 = (float)jarg3;
30428   arg4 = (float)jarg4;
30429   {
30430     try {
30431       (arg1)->SetScale(arg2,arg3,arg4);
30432     } catch (std::out_of_range& e) {
30433       {
30434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30435       };
30436     } catch (std::exception& e) {
30437       {
30438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (...) {
30441       {
30442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30443       };
30444     }
30445   }
30446 }
30447
30448
30449 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30451   Dali::Vector3 *arg2 = 0 ;
30452
30453   arg1 = (Dali::Actor *)jarg1;
30454   arg2 = (Dali::Vector3 *)jarg2;
30455   if (!arg2) {
30456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30457     return ;
30458   }
30459   {
30460     try {
30461       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30462     } catch (std::out_of_range& e) {
30463       {
30464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30465       };
30466     } catch (std::exception& e) {
30467       {
30468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30469       };
30470     } catch (...) {
30471       {
30472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30473       };
30474     }
30475   }
30476 }
30477
30478
30479 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_ScaleBy(void * jarg1, void * jarg2) {
30480   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30481   Dali::Vector3 *arg2 = 0 ;
30482
30483   arg1 = (Dali::Actor *)jarg1;
30484   arg2 = (Dali::Vector3 *)jarg2;
30485   if (!arg2) {
30486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30487     return ;
30488   }
30489   {
30490     try {
30491       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30492     } catch (std::out_of_range& e) {
30493       {
30494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30495       };
30496     } catch (std::exception& e) {
30497       {
30498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30499       };
30500     } catch (...) {
30501       {
30502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30503       };
30504     }
30505   }
30506 }
30507
30508
30509 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentScale(void * jarg1) {
30510   void * jresult ;
30511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30512   Dali::Vector3 result;
30513
30514   arg1 = (Dali::Actor *)jarg1;
30515   {
30516     try {
30517       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30518     } catch (std::out_of_range& e) {
30519       {
30520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30521       };
30522     } catch (std::exception& e) {
30523       {
30524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30525       };
30526     } catch (...) {
30527       {
30528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30529       };
30530     }
30531   }
30532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30533   return jresult;
30534 }
30535
30536
30537 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldScale(void * jarg1) {
30538   void * jresult ;
30539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30540   Dali::Vector3 result;
30541
30542   arg1 = (Dali::Actor *)jarg1;
30543   {
30544     try {
30545       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30546     } catch (std::out_of_range& e) {
30547       {
30548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30549       };
30550     } catch (std::exception& e) {
30551       {
30552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30553       };
30554     } catch (...) {
30555       {
30556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30557       };
30558     }
30559   }
30560   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30561   return jresult;
30562 }
30563
30564
30565 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30566   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30567   bool arg2 ;
30568
30569   arg1 = (Dali::Actor *)jarg1;
30570   arg2 = jarg2 ? true : false;
30571   {
30572     try {
30573       (arg1)->SetInheritScale(arg2);
30574     } catch (std::out_of_range& e) {
30575       {
30576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30577       };
30578     } catch (std::exception& e) {
30579       {
30580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30581       };
30582     } catch (...) {
30583       {
30584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30585       };
30586     }
30587   }
30588 }
30589
30590
30591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsScaleInherited(void * jarg1) {
30592   unsigned int jresult ;
30593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30594   bool result;
30595
30596   arg1 = (Dali::Actor *)jarg1;
30597   {
30598     try {
30599       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30600     } catch (std::out_of_range& e) {
30601       {
30602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30603       };
30604     } catch (std::exception& e) {
30605       {
30606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30607       };
30608     } catch (...) {
30609       {
30610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30611       };
30612     }
30613   }
30614   jresult = result;
30615   return jresult;
30616 }
30617
30618
30619 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldMatrix(void * jarg1) {
30620   void * jresult ;
30621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30622   Dali::Matrix result;
30623
30624   arg1 = (Dali::Actor *)jarg1;
30625   {
30626     try {
30627       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30628     } catch (std::out_of_range& e) {
30629       {
30630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30631       };
30632     } catch (std::exception& e) {
30633       {
30634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30635       };
30636     } catch (...) {
30637       {
30638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30639       };
30640     }
30641   }
30642   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30643   return jresult;
30644 }
30645
30646
30647 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30649   bool arg2 ;
30650
30651   arg1 = (Dali::Actor *)jarg1;
30652   arg2 = jarg2 ? true : false;
30653   {
30654     try {
30655       (arg1)->SetVisible(arg2);
30656     } catch (std::out_of_range& e) {
30657       {
30658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30659       };
30660     } catch (std::exception& e) {
30661       {
30662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30663       };
30664     } catch (...) {
30665       {
30666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30667       };
30668     }
30669   }
30670 }
30671
30672
30673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsVisible(void * jarg1) {
30674   unsigned int jresult ;
30675   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30676   bool result;
30677
30678   arg1 = (Dali::Actor *)jarg1;
30679   {
30680     try {
30681       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30682     } catch (std::out_of_range& e) {
30683       {
30684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30685       };
30686     } catch (std::exception& e) {
30687       {
30688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30689       };
30690     } catch (...) {
30691       {
30692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30693       };
30694     }
30695   }
30696   jresult = result;
30697   return jresult;
30698 }
30699
30700
30701 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOpacity(void * jarg1, float jarg2) {
30702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30703   float arg2 ;
30704
30705   arg1 = (Dali::Actor *)jarg1;
30706   arg2 = (float)jarg2;
30707   {
30708     try {
30709       (arg1)->SetOpacity(arg2);
30710     } catch (std::out_of_range& e) {
30711       {
30712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30713       };
30714     } catch (std::exception& e) {
30715       {
30716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30717       };
30718     } catch (...) {
30719       {
30720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30721       };
30722     }
30723   }
30724 }
30725
30726
30727 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetCurrentOpacity(void * jarg1) {
30728   float jresult ;
30729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30730   float result;
30731
30732   arg1 = (Dali::Actor *)jarg1;
30733   {
30734     try {
30735       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30736     } catch (std::out_of_range& e) {
30737       {
30738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30739       };
30740     } catch (std::exception& e) {
30741       {
30742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30743       };
30744     } catch (...) {
30745       {
30746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30747       };
30748     }
30749   }
30750   jresult = result;
30751   return jresult;
30752 }
30753
30754
30755 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetColor(void * jarg1, void * jarg2) {
30756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30757   Dali::Vector4 *arg2 = 0 ;
30758
30759   arg1 = (Dali::Actor *)jarg1;
30760   arg2 = (Dali::Vector4 *)jarg2;
30761   if (!arg2) {
30762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30763     return ;
30764   }
30765   {
30766     try {
30767       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30768     } catch (std::out_of_range& e) {
30769       {
30770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30771       };
30772     } catch (std::exception& e) {
30773       {
30774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30775       };
30776     } catch (...) {
30777       {
30778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30779       };
30780     }
30781   }
30782 }
30783
30784
30785 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentColor(void * jarg1) {
30786   void * jresult ;
30787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30788   Dali::Vector4 result;
30789
30790   arg1 = (Dali::Actor *)jarg1;
30791   {
30792     try {
30793       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30794     } catch (std::out_of_range& e) {
30795       {
30796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30797       };
30798     } catch (std::exception& e) {
30799       {
30800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30801       };
30802     } catch (...) {
30803       {
30804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30805       };
30806     }
30807   }
30808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30809   return jresult;
30810 }
30811
30812
30813 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetColorMode(void * jarg1, int jarg2) {
30814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30815   Dali::ColorMode arg2 ;
30816
30817   arg1 = (Dali::Actor *)jarg1;
30818   arg2 = (Dali::ColorMode)jarg2;
30819   {
30820     try {
30821       (arg1)->SetColorMode(arg2);
30822     } catch (std::out_of_range& e) {
30823       {
30824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30825       };
30826     } catch (std::exception& e) {
30827       {
30828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30829       };
30830     } catch (...) {
30831       {
30832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30833       };
30834     }
30835   }
30836 }
30837
30838
30839 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetColorMode(void * jarg1) {
30840   int jresult ;
30841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30842   Dali::ColorMode result;
30843
30844   arg1 = (Dali::Actor *)jarg1;
30845   {
30846     try {
30847       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
30848     } catch (std::out_of_range& e) {
30849       {
30850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30851       };
30852     } catch (std::exception& e) {
30853       {
30854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30855       };
30856     } catch (...) {
30857       {
30858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30859       };
30860     }
30861   }
30862   jresult = (int)result;
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldColor(void * jarg1) {
30868   void * jresult ;
30869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30870   Dali::Vector4 result;
30871
30872   arg1 = (Dali::Actor *)jarg1;
30873   {
30874     try {
30875       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
30876     } catch (std::out_of_range& e) {
30877       {
30878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30879       };
30880     } catch (std::exception& e) {
30881       {
30882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30883       };
30884     } catch (...) {
30885       {
30886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30887       };
30888     }
30889   }
30890   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30891   return jresult;
30892 }
30893
30894
30895 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetDrawMode(void * jarg1, int jarg2) {
30896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30897   Dali::DrawMode::Type arg2 ;
30898
30899   arg1 = (Dali::Actor *)jarg1;
30900   arg2 = (Dali::DrawMode::Type)jarg2;
30901   {
30902     try {
30903       (arg1)->SetDrawMode(arg2);
30904     } catch (std::out_of_range& e) {
30905       {
30906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30907       };
30908     } catch (std::exception& e) {
30909       {
30910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30911       };
30912     } catch (...) {
30913       {
30914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30915       };
30916     }
30917   }
30918 }
30919
30920
30921 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetDrawMode(void * jarg1) {
30922   int jresult ;
30923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30924   Dali::DrawMode::Type result;
30925
30926   arg1 = (Dali::Actor *)jarg1;
30927   {
30928     try {
30929       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
30930     } catch (std::out_of_range& e) {
30931       {
30932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (std::exception& e) {
30935       {
30936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (...) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30941       };
30942     }
30943   }
30944   jresult = (int)result;
30945   return jresult;
30946 }
30947
30948
30949 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
30950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30951   bool arg2 ;
30952
30953   arg1 = (Dali::Actor *)jarg1;
30954   arg2 = jarg2 ? true : false;
30955   {
30956     try {
30957       (arg1)->SetSensitive(arg2);
30958     } catch (std::out_of_range& e) {
30959       {
30960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30961       };
30962     } catch (std::exception& e) {
30963       {
30964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30965       };
30966     } catch (...) {
30967       {
30968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30969       };
30970     }
30971   }
30972 }
30973
30974
30975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsSensitive(void * jarg1) {
30976   unsigned int jresult ;
30977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30978   bool result;
30979
30980   arg1 = (Dali::Actor *)jarg1;
30981   {
30982     try {
30983       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
30984     } catch (std::out_of_range& e) {
30985       {
30986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30987       };
30988     } catch (std::exception& e) {
30989       {
30990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30991       };
30992     } catch (...) {
30993       {
30994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30995       };
30996     }
30997   }
30998   jresult = result;
30999   return jresult;
31000 }
31001
31002
31003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31004   unsigned int jresult ;
31005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31006   float *arg2 = 0 ;
31007   float *arg3 = 0 ;
31008   float arg4 ;
31009   float arg5 ;
31010   bool result;
31011
31012   arg1 = (Dali::Actor *)jarg1;
31013   arg2 = (float *)jarg2;
31014   arg3 = (float *)jarg3;
31015   arg4 = (float)jarg4;
31016   arg5 = (float)jarg5;
31017   {
31018     try {
31019       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31020     } catch (std::out_of_range& e) {
31021       {
31022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31023       };
31024     } catch (std::exception& e) {
31025       {
31026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31027       };
31028     } catch (...) {
31029       {
31030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31031       };
31032     }
31033   }
31034   jresult = result;
31035   return jresult;
31036 }
31037
31038
31039 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31040   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31041   bool arg2 ;
31042
31043   arg1 = (Dali::Actor *)jarg1;
31044   arg2 = jarg2 ? true : false;
31045   {
31046     try {
31047       (arg1)->SetLeaveRequired(arg2);
31048     } catch (std::out_of_range& e) {
31049       {
31050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31051       };
31052     } catch (std::exception& e) {
31053       {
31054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31055       };
31056     } catch (...) {
31057       {
31058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31059       };
31060     }
31061   }
31062 }
31063
31064
31065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetLeaveRequired(void * jarg1) {
31066   unsigned int jresult ;
31067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31068   bool result;
31069
31070   arg1 = (Dali::Actor *)jarg1;
31071   {
31072     try {
31073       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31074     } catch (std::out_of_range& e) {
31075       {
31076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31077       };
31078     } catch (std::exception& e) {
31079       {
31080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31081       };
31082     } catch (...) {
31083       {
31084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31085       };
31086     }
31087   }
31088   jresult = result;
31089   return jresult;
31090 }
31091
31092
31093 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31095   bool arg2 ;
31096
31097   arg1 = (Dali::Actor *)jarg1;
31098   arg2 = jarg2 ? true : false;
31099   {
31100     try {
31101       (arg1)->SetKeyboardFocusable(arg2);
31102     } catch (std::out_of_range& e) {
31103       {
31104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31105       };
31106     } catch (std::exception& e) {
31107       {
31108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31109       };
31110     } catch (...) {
31111       {
31112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31113       };
31114     }
31115   }
31116 }
31117
31118
31119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsKeyboardFocusable(void * jarg1) {
31120   unsigned int jresult ;
31121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31122   bool result;
31123
31124   arg1 = (Dali::Actor *)jarg1;
31125   {
31126     try {
31127       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31128     } catch (std::out_of_range& e) {
31129       {
31130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31131       };
31132     } catch (std::exception& e) {
31133       {
31134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31135       };
31136     } catch (...) {
31137       {
31138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31139       };
31140     }
31141   }
31142   jresult = result;
31143   return jresult;
31144 }
31145
31146
31147 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31149   Dali::ResizePolicy::Type arg2 ;
31150   Dali::Dimension::Type arg3 ;
31151
31152   arg1 = (Dali::Actor *)jarg1;
31153   arg2 = (Dali::ResizePolicy::Type)jarg2;
31154   arg3 = (Dali::Dimension::Type)jarg3;
31155   {
31156     try {
31157       (arg1)->SetResizePolicy(arg2,arg3);
31158     } catch (std::out_of_range& e) {
31159       {
31160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31161       };
31162     } catch (std::exception& e) {
31163       {
31164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31165       };
31166     } catch (...) {
31167       {
31168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31169       };
31170     }
31171   }
31172 }
31173
31174
31175 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31176   int jresult ;
31177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31178   Dali::Dimension::Type arg2 ;
31179   Dali::ResizePolicy::Type result;
31180
31181   arg1 = (Dali::Actor *)jarg1;
31182   arg2 = (Dali::Dimension::Type)jarg2;
31183   {
31184     try {
31185       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31186     } catch (std::out_of_range& e) {
31187       {
31188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31189       };
31190     } catch (std::exception& e) {
31191       {
31192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31193       };
31194     } catch (...) {
31195       {
31196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31197       };
31198     }
31199   }
31200   jresult = (int)result;
31201   return jresult;
31202 }
31203
31204
31205 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31207   Dali::SizeScalePolicy::Type arg2 ;
31208
31209   arg1 = (Dali::Actor *)jarg1;
31210   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31211   {
31212     try {
31213       (arg1)->SetSizeScalePolicy(arg2);
31214     } catch (std::out_of_range& e) {
31215       {
31216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31217       };
31218     } catch (std::exception& e) {
31219       {
31220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31221       };
31222     } catch (...) {
31223       {
31224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31225       };
31226     }
31227   }
31228 }
31229
31230
31231 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetSizeScalePolicy(void * jarg1) {
31232   int jresult ;
31233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31234   Dali::SizeScalePolicy::Type result;
31235
31236   arg1 = (Dali::Actor *)jarg1;
31237   {
31238     try {
31239       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31240     } catch (std::out_of_range& e) {
31241       {
31242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (std::exception& e) {
31245       {
31246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (...) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31251       };
31252     }
31253   }
31254   jresult = (int)result;
31255   return jresult;
31256 }
31257
31258
31259 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31261   Dali::Vector3 *arg2 = 0 ;
31262
31263   arg1 = (Dali::Actor *)jarg1;
31264   arg2 = (Dali::Vector3 *)jarg2;
31265   if (!arg2) {
31266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31267     return ;
31268   }
31269   {
31270     try {
31271       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31272     } catch (std::out_of_range& e) {
31273       {
31274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31275       };
31276     } catch (std::exception& e) {
31277       {
31278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31279       };
31280     } catch (...) {
31281       {
31282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31283       };
31284     }
31285   }
31286 }
31287
31288
31289 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetSizeModeFactor(void * jarg1) {
31290   void * jresult ;
31291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31292   Dali::Vector3 result;
31293
31294   arg1 = (Dali::Actor *)jarg1;
31295   {
31296     try {
31297       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31298     } catch (std::out_of_range& e) {
31299       {
31300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31301       };
31302     } catch (std::exception& e) {
31303       {
31304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31305       };
31306     } catch (...) {
31307       {
31308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31309       };
31310     }
31311   }
31312   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31318   float jresult ;
31319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31320   float arg2 ;
31321   float result;
31322
31323   arg1 = (Dali::Actor *)jarg1;
31324   arg2 = (float)jarg2;
31325   {
31326     try {
31327       result = (float)(arg1)->GetHeightForWidth(arg2);
31328     } catch (std::out_of_range& e) {
31329       {
31330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31331       };
31332     } catch (std::exception& e) {
31333       {
31334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31335       };
31336     } catch (...) {
31337       {
31338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31339       };
31340     }
31341   }
31342   jresult = result;
31343   return jresult;
31344 }
31345
31346
31347 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31348   float jresult ;
31349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31350   float arg2 ;
31351   float result;
31352
31353   arg1 = (Dali::Actor *)jarg1;
31354   arg2 = (float)jarg2;
31355   {
31356     try {
31357       result = (float)(arg1)->GetWidthForHeight(arg2);
31358     } catch (std::out_of_range& e) {
31359       {
31360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31361       };
31362     } catch (std::exception& e) {
31363       {
31364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31365       };
31366     } catch (...) {
31367       {
31368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31369       };
31370     }
31371   }
31372   jresult = result;
31373   return jresult;
31374 }
31375
31376
31377 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31378   float jresult ;
31379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31380   Dali::Dimension::Type arg2 ;
31381   float result;
31382
31383   arg1 = (Dali::Actor *)jarg1;
31384   arg2 = (Dali::Dimension::Type)jarg2;
31385   {
31386     try {
31387       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31395       };
31396     } catch (...) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31399       };
31400     }
31401   }
31402   jresult = result;
31403   return jresult;
31404 }
31405
31406
31407 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPadding(void * jarg1, void * jarg2) {
31408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31409   Dali::Padding *arg2 = 0 ;
31410
31411   arg1 = (Dali::Actor *)jarg1;
31412   arg2 = (Dali::Padding *)jarg2;
31413   if (!arg2) {
31414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31415     return ;
31416   }
31417   {
31418     try {
31419       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31420     } catch (std::out_of_range& e) {
31421       {
31422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31423       };
31424     } catch (std::exception& e) {
31425       {
31426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31427       };
31428     } catch (...) {
31429       {
31430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31431       };
31432     }
31433   }
31434 }
31435
31436
31437 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_GetPadding(void * jarg1, void * jarg2) {
31438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31439   Dali::Padding *arg2 = 0 ;
31440
31441   arg1 = (Dali::Actor *)jarg1;
31442   arg2 = (Dali::Padding *)jarg2;
31443   if (!arg2) {
31444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31445     return ;
31446   }
31447   {
31448     try {
31449       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31450     } catch (std::out_of_range& e) {
31451       {
31452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31453       };
31454     } catch (std::exception& e) {
31455       {
31456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31457       };
31458     } catch (...) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31461       };
31462     }
31463   }
31464 }
31465
31466
31467 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31469   Dali::Vector2 *arg2 = 0 ;
31470
31471   arg1 = (Dali::Actor *)jarg1;
31472   arg2 = (Dali::Vector2 *)jarg2;
31473   if (!arg2) {
31474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31475     return ;
31476   }
31477   {
31478     try {
31479       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31480     } catch (std::out_of_range& e) {
31481       {
31482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31483       };
31484     } catch (std::exception& e) {
31485       {
31486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31487       };
31488     } catch (...) {
31489       {
31490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31491       };
31492     }
31493   }
31494 }
31495
31496
31497 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetMinimumSize(void * jarg1) {
31498   void * jresult ;
31499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31500   Dali::Vector2 result;
31501
31502   arg1 = (Dali::Actor *)jarg1;
31503   {
31504     try {
31505       result = (arg1)->GetMinimumSize();
31506     } catch (std::out_of_range& e) {
31507       {
31508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31509       };
31510     } catch (std::exception& e) {
31511       {
31512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31513       };
31514     } catch (...) {
31515       {
31516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31517       };
31518     }
31519   }
31520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31521   return jresult;
31522 }
31523
31524
31525 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31526   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31527   Dali::Vector2 *arg2 = 0 ;
31528
31529   arg1 = (Dali::Actor *)jarg1;
31530   arg2 = (Dali::Vector2 *)jarg2;
31531   if (!arg2) {
31532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31533     return ;
31534   }
31535   {
31536     try {
31537       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31538     } catch (std::out_of_range& e) {
31539       {
31540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31541       };
31542     } catch (std::exception& e) {
31543       {
31544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31545       };
31546     } catch (...) {
31547       {
31548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31549       };
31550     }
31551   }
31552 }
31553
31554
31555 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetMaximumSize(void * jarg1) {
31556   void * jresult ;
31557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31558   Dali::Vector2 result;
31559
31560   arg1 = (Dali::Actor *)jarg1;
31561   {
31562     try {
31563       result = (arg1)->GetMaximumSize();
31564     } catch (std::out_of_range& e) {
31565       {
31566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31567       };
31568     } catch (std::exception& e) {
31569       {
31570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31571       };
31572     } catch (...) {
31573       {
31574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31575       };
31576     }
31577   }
31578   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31579   return jresult;
31580 }
31581
31582
31583 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetHierarchyDepth(void * jarg1) {
31584   int jresult ;
31585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31586   int result;
31587
31588   arg1 = (Dali::Actor *)jarg1;
31589   {
31590     try {
31591       result = (int)(arg1)->GetHierarchyDepth();
31592     } catch (std::out_of_range& e) {
31593       {
31594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31595       };
31596     } catch (std::exception& e) {
31597       {
31598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31599       };
31600     } catch (...) {
31601       {
31602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31603       };
31604     }
31605   }
31606   jresult = result;
31607   return jresult;
31608 }
31609
31610
31611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_AddRenderer(void * jarg1, void * jarg2) {
31612   unsigned int jresult ;
31613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31614   Dali::Renderer *arg2 = 0 ;
31615   unsigned int result;
31616
31617   arg1 = (Dali::Actor *)jarg1;
31618   arg2 = (Dali::Renderer *)jarg2;
31619   if (!arg2) {
31620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31621     return 0;
31622   }
31623   {
31624     try {
31625       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31626     } catch (std::out_of_range& e) {
31627       {
31628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31629       };
31630     } catch (std::exception& e) {
31631       {
31632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31633       };
31634     } catch (...) {
31635       {
31636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31637       };
31638     }
31639   }
31640   jresult = result;
31641   return jresult;
31642 }
31643
31644
31645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetRendererCount(void * jarg1) {
31646   unsigned int jresult ;
31647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31648   unsigned int result;
31649
31650   arg1 = (Dali::Actor *)jarg1;
31651   {
31652     try {
31653       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31654     } catch (std::out_of_range& e) {
31655       {
31656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31657       };
31658     } catch (std::exception& e) {
31659       {
31660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31661       };
31662     } catch (...) {
31663       {
31664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31665       };
31666     }
31667   }
31668   jresult = result;
31669   return jresult;
31670 }
31671
31672
31673 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31674   void * jresult ;
31675   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31676   unsigned int arg2 ;
31677   Dali::Renderer result;
31678
31679   arg1 = (Dali::Actor *)jarg1;
31680   arg2 = (unsigned int)jarg2;
31681   {
31682     try {
31683       result = (arg1)->GetRendererAt(arg2);
31684     } catch (std::out_of_range& e) {
31685       {
31686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31687       };
31688     } catch (std::exception& e) {
31689       {
31690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31691       };
31692     } catch (...) {
31693       {
31694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31695       };
31696     }
31697   }
31698   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31699   return jresult;
31700 }
31701
31702
31703 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31705   Dali::Renderer *arg2 = 0 ;
31706
31707   arg1 = (Dali::Actor *)jarg1;
31708   arg2 = (Dali::Renderer *)jarg2;
31709   if (!arg2) {
31710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31711     return ;
31712   }
31713   {
31714     try {
31715       (arg1)->RemoveRenderer(*arg2);
31716     } catch (std::out_of_range& e) {
31717       {
31718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31719       };
31720     } catch (std::exception& e) {
31721       {
31722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31723       };
31724     } catch (...) {
31725       {
31726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31727       };
31728     }
31729   }
31730 }
31731
31732
31733 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31735   unsigned int arg2 ;
31736
31737   arg1 = (Dali::Actor *)jarg1;
31738   arg2 = (unsigned int)jarg2;
31739   {
31740     try {
31741       (arg1)->RemoveRenderer(arg2);
31742     } catch (std::out_of_range& e) {
31743       {
31744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (std::exception& e) {
31747       {
31748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31753       };
31754     }
31755   }
31756 }
31757
31758
31759 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_TouchedSignal(void * jarg1) {
31760   void * jresult ;
31761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31762   Dali::Actor::TouchSignalType *result = 0 ;
31763
31764   arg1 = (Dali::Actor *)jarg1;
31765   {
31766     try {
31767       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31768     } catch (std::out_of_range& e) {
31769       {
31770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31771       };
31772     } catch (std::exception& e) {
31773       {
31774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (...) {
31777       {
31778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31779       };
31780     }
31781   }
31782   jresult = (void *)result;
31783   return jresult;
31784 }
31785
31786
31787 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_TouchSignal(void * jarg1) {
31788   void * jresult ;
31789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31790   Dali::Actor::TouchDataSignalType *result = 0 ;
31791
31792   arg1 = (Dali::Actor *)jarg1;
31793   {
31794     try {
31795       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31803       };
31804     } catch (...) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31807       };
31808     }
31809   }
31810   jresult = (void *)result;
31811   return jresult;
31812 }
31813
31814
31815 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_HoveredSignal(void * jarg1) {
31816   void * jresult ;
31817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31818   Dali::Actor::HoverSignalType *result = 0 ;
31819
31820   arg1 = (Dali::Actor *)jarg1;
31821   {
31822     try {
31823       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
31824     } catch (std::out_of_range& e) {
31825       {
31826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (std::exception& e) {
31829       {
31830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31831       };
31832     } catch (...) {
31833       {
31834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31835       };
31836     }
31837   }
31838   jresult = (void *)result;
31839   return jresult;
31840 }
31841
31842
31843 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_WheelEventSignal(void * jarg1) {
31844   void * jresult ;
31845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31846   Dali::Actor::WheelEventSignalType *result = 0 ;
31847
31848   arg1 = (Dali::Actor *)jarg1;
31849   {
31850     try {
31851       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
31852     } catch (std::out_of_range& e) {
31853       {
31854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31855       };
31856     } catch (std::exception& e) {
31857       {
31858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31859       };
31860     } catch (...) {
31861       {
31862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31863       };
31864     }
31865   }
31866   jresult = (void *)result;
31867   return jresult;
31868 }
31869
31870
31871 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OnStageSignal(void * jarg1) {
31872   void * jresult ;
31873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31874   Dali::Actor::OnStageSignalType *result = 0 ;
31875
31876   arg1 = (Dali::Actor *)jarg1;
31877   {
31878     try {
31879       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
31880     } catch (std::out_of_range& e) {
31881       {
31882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31883       };
31884     } catch (std::exception& e) {
31885       {
31886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31887       };
31888     } catch (...) {
31889       {
31890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31891       };
31892     }
31893   }
31894   jresult = (void *)result;
31895   return jresult;
31896 }
31897
31898
31899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OffStageSignal(void * jarg1) {
31900   void * jresult ;
31901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31902   Dali::Actor::OffStageSignalType *result = 0 ;
31903
31904   arg1 = (Dali::Actor *)jarg1;
31905   {
31906     try {
31907       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
31908     } catch (std::out_of_range& e) {
31909       {
31910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31911       };
31912     } catch (std::exception& e) {
31913       {
31914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31915       };
31916     } catch (...) {
31917       {
31918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31919       };
31920     }
31921   }
31922   jresult = (void *)result;
31923   return jresult;
31924 }
31925
31926
31927 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OnRelayoutSignal(void * jarg1) {
31928   void * jresult ;
31929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31930   Dali::Actor::OnRelayoutSignalType *result = 0 ;
31931
31932   arg1 = (Dali::Actor *)jarg1;
31933   {
31934     try {
31935       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
31936     } catch (std::out_of_range& e) {
31937       {
31938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31939       };
31940     } catch (std::exception& e) {
31941       {
31942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31943       };
31944     } catch (...) {
31945       {
31946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31947       };
31948     }
31949   }
31950   jresult = (void *)result;
31951   return jresult;
31952 }
31953
31954
31955 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_UnparentAndReset(void * jarg1) {
31956   Dali::Actor *arg1 = 0 ;
31957
31958   arg1 = (Dali::Actor *)jarg1;
31959   if (!arg1) {
31960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
31961     return ;
31962   }
31963   {
31964     try {
31965       Dali::UnparentAndReset(*arg1);
31966     } catch (std::out_of_range& e) {
31967       {
31968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31969       };
31970     } catch (std::exception& e) {
31971       {
31972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31973       };
31974     } catch (...) {
31975       {
31976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31977       };
31978     }
31979   }
31980 }
31981
31982
31983 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_CLIPPING_ENABLE_get() {
31984   int jresult ;
31985   int result;
31986
31987   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
31988   jresult = (int)result;
31989   return jresult;
31990 }
31991
31992
31993 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_CLIPPING_BOX_get() {
31994   int jresult ;
31995   int result;
31996
31997   result = (int)Dali::Layer::Property::CLIPPING_BOX;
31998   jresult = (int)result;
31999   return jresult;
32000 }
32001
32002
32003 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_BEHAVIOR_get() {
32004   int jresult ;
32005   int result;
32006
32007   result = (int)Dali::Layer::Property::BEHAVIOR;
32008   jresult = (int)result;
32009   return jresult;
32010 }
32011
32012
32013 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer_Property() {
32014   void * jresult ;
32015   Dali::Layer::Property *result = 0 ;
32016
32017   {
32018     try {
32019       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32020     } catch (std::out_of_range& e) {
32021       {
32022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32023       };
32024     } catch (std::exception& e) {
32025       {
32026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32027       };
32028     } catch (...) {
32029       {
32030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32031       };
32032     }
32033   }
32034   jresult = (void *)result;
32035   return jresult;
32036 }
32037
32038
32039 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Layer_Property(void * jarg1) {
32040   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32041
32042   arg1 = (Dali::Layer::Property *)jarg1;
32043   {
32044     try {
32045       delete arg1;
32046     } catch (std::out_of_range& e) {
32047       {
32048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32049       };
32050     } catch (std::exception& e) {
32051       {
32052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32053       };
32054     } catch (...) {
32055       {
32056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32057       };
32058     }
32059   }
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer__SWIG_0() {
32064   void * jresult ;
32065   Dali::Layer *result = 0 ;
32066
32067   {
32068     try {
32069       result = (Dali::Layer *)new Dali::Layer();
32070     } catch (std::out_of_range& e) {
32071       {
32072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32073       };
32074     } catch (std::exception& e) {
32075       {
32076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32077       };
32078     } catch (...) {
32079       {
32080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32081       };
32082     }
32083   }
32084   jresult = (void *)result;
32085   return jresult;
32086 }
32087
32088
32089 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_New() {
32090   void * jresult ;
32091   Dali::Layer result;
32092
32093   {
32094     try {
32095       result = Dali::Layer::New();
32096     } catch (std::out_of_range& e) {
32097       {
32098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (std::exception& e) {
32101       {
32102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (...) {
32105       {
32106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32107       };
32108     }
32109   }
32110   jresult = new Dali::Layer((const Dali::Layer &)result);
32111   return jresult;
32112 }
32113
32114
32115 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_DownCast(void * jarg1) {
32116   void * jresult ;
32117   Dali::BaseHandle arg1 ;
32118   Dali::BaseHandle *argp1 ;
32119   Dali::Layer result;
32120
32121   argp1 = (Dali::BaseHandle *)jarg1;
32122   if (!argp1) {
32123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32124     return 0;
32125   }
32126   arg1 = *argp1;
32127   {
32128     try {
32129       result = Dali::Layer::DownCast(arg1);
32130     } catch (std::out_of_range& e) {
32131       {
32132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32133       };
32134     } catch (std::exception& e) {
32135       {
32136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32137       };
32138     } catch (...) {
32139       {
32140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32141       };
32142     }
32143   }
32144   jresult = new Dali::Layer((const Dali::Layer &)result);
32145   return jresult;
32146 }
32147
32148
32149 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Layer(void * jarg1) {
32150   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32151
32152   arg1 = (Dali::Layer *)jarg1;
32153   {
32154     try {
32155       delete arg1;
32156     } catch (std::out_of_range& e) {
32157       {
32158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32159       };
32160     } catch (std::exception& e) {
32161       {
32162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32167       };
32168     }
32169   }
32170 }
32171
32172
32173 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer__SWIG_1(void * jarg1) {
32174   void * jresult ;
32175   Dali::Layer *arg1 = 0 ;
32176   Dali::Layer *result = 0 ;
32177
32178   arg1 = (Dali::Layer *)jarg1;
32179   if (!arg1) {
32180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32181     return 0;
32182   }
32183   {
32184     try {
32185       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32186     } catch (std::out_of_range& e) {
32187       {
32188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32189       };
32190     } catch (std::exception& e) {
32191       {
32192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32193       };
32194     } catch (...) {
32195       {
32196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32197       };
32198     }
32199   }
32200   jresult = (void *)result;
32201   return jresult;
32202 }
32203
32204
32205 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_Assign(void * jarg1, void * jarg2) {
32206   void * jresult ;
32207   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32208   Dali::Layer *arg2 = 0 ;
32209   Dali::Layer *result = 0 ;
32210
32211   arg1 = (Dali::Layer *)jarg1;
32212   arg2 = (Dali::Layer *)jarg2;
32213   if (!arg2) {
32214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32215     return 0;
32216   }
32217   {
32218     try {
32219       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32220     } catch (std::out_of_range& e) {
32221       {
32222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32223       };
32224     } catch (std::exception& e) {
32225       {
32226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32227       };
32228     } catch (...) {
32229       {
32230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32231       };
32232     }
32233   }
32234   jresult = (void *)result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_GetDepth(void * jarg1) {
32240   unsigned int jresult ;
32241   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32242   unsigned int result;
32243
32244   arg1 = (Dali::Layer *)jarg1;
32245   {
32246     try {
32247       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32248     } catch (std::out_of_range& e) {
32249       {
32250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (std::exception& e) {
32253       {
32254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (...) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32259       };
32260     }
32261   }
32262   jresult = result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_Raise(void * jarg1) {
32268   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32269
32270   arg1 = (Dali::Layer *)jarg1;
32271   {
32272     try {
32273       (arg1)->Raise();
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (...) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32285       };
32286     }
32287   }
32288 }
32289
32290
32291 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_Lower(void * jarg1) {
32292   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32293
32294   arg1 = (Dali::Layer *)jarg1;
32295   {
32296     try {
32297       (arg1)->Lower();
32298     } catch (std::out_of_range& e) {
32299       {
32300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32301       };
32302     } catch (std::exception& e) {
32303       {
32304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32305       };
32306     } catch (...) {
32307       {
32308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32309       };
32310     }
32311   }
32312 }
32313
32314
32315 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32316   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32317   Dali::Layer arg2 ;
32318   Dali::Layer *argp2 ;
32319
32320   arg1 = (Dali::Layer *)jarg1;
32321   argp2 = (Dali::Layer *)jarg2;
32322   if (!argp2) {
32323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32324     return ;
32325   }
32326   arg2 = *argp2;
32327   {
32328     try {
32329       (arg1)->RaiseAbove(arg2);
32330     } catch (std::out_of_range& e) {
32331       {
32332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32333       };
32334     } catch (std::exception& e) {
32335       {
32336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32337       };
32338     } catch (...) {
32339       {
32340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32341       };
32342     }
32343   }
32344 }
32345
32346
32347 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_LowerBelow(void * jarg1, void * jarg2) {
32348   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32349   Dali::Layer arg2 ;
32350   Dali::Layer *argp2 ;
32351
32352   arg1 = (Dali::Layer *)jarg1;
32353   argp2 = (Dali::Layer *)jarg2;
32354   if (!argp2) {
32355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32356     return ;
32357   }
32358   arg2 = *argp2;
32359   {
32360     try {
32361       (arg1)->LowerBelow(arg2);
32362     } catch (std::out_of_range& e) {
32363       {
32364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32365       };
32366     } catch (std::exception& e) {
32367       {
32368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32369       };
32370     } catch (...) {
32371       {
32372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32373       };
32374     }
32375   }
32376 }
32377
32378
32379 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_RaiseToTop(void * jarg1) {
32380   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32381
32382   arg1 = (Dali::Layer *)jarg1;
32383   {
32384     try {
32385       (arg1)->RaiseToTop();
32386     } catch (std::out_of_range& e) {
32387       {
32388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32389       };
32390     } catch (std::exception& e) {
32391       {
32392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32393       };
32394     } catch (...) {
32395       {
32396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32397       };
32398     }
32399   }
32400 }
32401
32402
32403 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_LowerToBottom(void * jarg1) {
32404   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32405
32406   arg1 = (Dali::Layer *)jarg1;
32407   {
32408     try {
32409       (arg1)->LowerToBottom();
32410     } catch (std::out_of_range& e) {
32411       {
32412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32413       };
32414     } catch (std::exception& e) {
32415       {
32416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32417       };
32418     } catch (...) {
32419       {
32420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32421       };
32422     }
32423   }
32424 }
32425
32426
32427 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_MoveAbove(void * jarg1, void * jarg2) {
32428   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32429   Dali::Layer arg2 ;
32430   Dali::Layer *argp2 ;
32431
32432   arg1 = (Dali::Layer *)jarg1;
32433   argp2 = (Dali::Layer *)jarg2;
32434   if (!argp2) {
32435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32436     return ;
32437   }
32438   arg2 = *argp2;
32439   {
32440     try {
32441       (arg1)->MoveAbove(arg2);
32442     } catch (std::out_of_range& e) {
32443       {
32444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32445       };
32446     } catch (std::exception& e) {
32447       {
32448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32449       };
32450     } catch (...) {
32451       {
32452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32453       };
32454     }
32455   }
32456 }
32457
32458
32459 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_MoveBelow(void * jarg1, void * jarg2) {
32460   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32461   Dali::Layer arg2 ;
32462   Dali::Layer *argp2 ;
32463
32464   arg1 = (Dali::Layer *)jarg1;
32465   argp2 = (Dali::Layer *)jarg2;
32466   if (!argp2) {
32467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32468     return ;
32469   }
32470   arg2 = *argp2;
32471   {
32472     try {
32473       (arg1)->MoveBelow(arg2);
32474     } catch (std::out_of_range& e) {
32475       {
32476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32477       };
32478     } catch (std::exception& e) {
32479       {
32480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32481       };
32482     } catch (...) {
32483       {
32484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32485       };
32486     }
32487   }
32488 }
32489
32490
32491 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetBehavior(void * jarg1, int jarg2) {
32492   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32493   Dali::Layer::Behavior arg2 ;
32494
32495   arg1 = (Dali::Layer *)jarg1;
32496   arg2 = (Dali::Layer::Behavior)jarg2;
32497   {
32498     try {
32499       (arg1)->SetBehavior(arg2);
32500     } catch (std::out_of_range& e) {
32501       {
32502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32503       };
32504     } catch (std::exception& e) {
32505       {
32506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32507       };
32508     } catch (...) {
32509       {
32510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32511       };
32512     }
32513   }
32514 }
32515
32516
32517 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_GetBehavior(void * jarg1) {
32518   int jresult ;
32519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32520   Dali::Layer::Behavior result;
32521
32522   arg1 = (Dali::Layer *)jarg1;
32523   {
32524     try {
32525       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32526     } catch (std::out_of_range& e) {
32527       {
32528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32529       };
32530     } catch (std::exception& e) {
32531       {
32532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32533       };
32534     } catch (...) {
32535       {
32536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32537       };
32538     }
32539   }
32540   jresult = (int)result;
32541   return jresult;
32542 }
32543
32544
32545 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32546   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32547   bool arg2 ;
32548
32549   arg1 = (Dali::Layer *)jarg1;
32550   arg2 = jarg2 ? true : false;
32551   {
32552     try {
32553       (arg1)->SetClipping(arg2);
32554     } catch (std::out_of_range& e) {
32555       {
32556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32557       };
32558     } catch (std::exception& e) {
32559       {
32560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32561       };
32562     } catch (...) {
32563       {
32564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32565       };
32566     }
32567   }
32568 }
32569
32570
32571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsClipping(void * jarg1) {
32572   unsigned int jresult ;
32573   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32574   bool result;
32575
32576   arg1 = (Dali::Layer *)jarg1;
32577   {
32578     try {
32579       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32580     } catch (std::out_of_range& e) {
32581       {
32582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32583       };
32584     } catch (std::exception& e) {
32585       {
32586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32587       };
32588     } catch (...) {
32589       {
32590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32591       };
32592     }
32593   }
32594   jresult = result;
32595   return jresult;
32596 }
32597
32598
32599 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32600   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32601   int arg2 ;
32602   int arg3 ;
32603   int arg4 ;
32604   int arg5 ;
32605
32606   arg1 = (Dali::Layer *)jarg1;
32607   arg2 = (int)jarg2;
32608   arg3 = (int)jarg3;
32609   arg4 = (int)jarg4;
32610   arg5 = (int)jarg5;
32611   {
32612     try {
32613       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32614     } catch (std::out_of_range& e) {
32615       {
32616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32617       };
32618     } catch (std::exception& e) {
32619       {
32620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32621       };
32622     } catch (...) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32625       };
32626     }
32627   }
32628 }
32629
32630
32631 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
32632   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32633   Dali::ClippingBox arg2 ;
32634   Dali::ClippingBox *argp2 ;
32635
32636   arg1 = (Dali::Layer *)jarg1;
32637   argp2 = (Dali::ClippingBox *)jarg2;
32638   if (!argp2) {
32639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
32640     return ;
32641   }
32642   arg2 = *argp2;
32643   {
32644     try {
32645       (arg1)->SetClippingBox(arg2);
32646     } catch (std::out_of_range& e) {
32647       {
32648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32649       };
32650     } catch (std::exception& e) {
32651       {
32652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32653       };
32654     } catch (...) {
32655       {
32656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32657       };
32658     }
32659   }
32660 }
32661
32662
32663 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_GetClippingBox(void * jarg1) {
32664   void * jresult ;
32665   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32666   Dali::ClippingBox result;
32667
32668   arg1 = (Dali::Layer *)jarg1;
32669   {
32670     try {
32671       result = ((Dali::Layer const *)arg1)->GetClippingBox();
32672     } catch (std::out_of_range& e) {
32673       {
32674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32675       };
32676     } catch (std::exception& e) {
32677       {
32678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32679       };
32680     } catch (...) {
32681       {
32682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32683       };
32684     }
32685   }
32686   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
32692   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32693   bool arg2 ;
32694
32695   arg1 = (Dali::Layer *)jarg1;
32696   arg2 = jarg2 ? true : false;
32697   {
32698     try {
32699       (arg1)->SetDepthTestDisabled(arg2);
32700     } catch (std::out_of_range& e) {
32701       {
32702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32703       };
32704     } catch (std::exception& e) {
32705       {
32706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (...) {
32709       {
32710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32711       };
32712     }
32713   }
32714 }
32715
32716
32717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsDepthTestDisabled(void * jarg1) {
32718   unsigned int jresult ;
32719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32720   bool result;
32721
32722   arg1 = (Dali::Layer *)jarg1;
32723   {
32724     try {
32725       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
32726     } catch (std::out_of_range& e) {
32727       {
32728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32729       };
32730     } catch (std::exception& e) {
32731       {
32732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32733       };
32734     } catch (...) {
32735       {
32736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32737       };
32738     }
32739   }
32740   jresult = result;
32741   return jresult;
32742 }
32743
32744
32745 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetSortFunction(void * jarg1, void * jarg2) {
32746   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32747   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
32748
32749   arg1 = (Dali::Layer *)jarg1;
32750   arg2 = (Dali::Layer::SortFunctionType)jarg2;
32751   {
32752     try {
32753       (arg1)->SetSortFunction(arg2);
32754     } catch (std::out_of_range& e) {
32755       {
32756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32757       };
32758     } catch (std::exception& e) {
32759       {
32760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32761       };
32762     } catch (...) {
32763       {
32764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32765       };
32766     }
32767   }
32768 }
32769
32770
32771 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
32772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32773   bool arg2 ;
32774
32775   arg1 = (Dali::Layer *)jarg1;
32776   arg2 = jarg2 ? true : false;
32777   {
32778     try {
32779       (arg1)->SetTouchConsumed(arg2);
32780     } catch (std::out_of_range& e) {
32781       {
32782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32783       };
32784     } catch (std::exception& e) {
32785       {
32786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32787       };
32788     } catch (...) {
32789       {
32790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32791       };
32792     }
32793   }
32794 }
32795
32796
32797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsTouchConsumed(void * jarg1) {
32798   unsigned int jresult ;
32799   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32800   bool result;
32801
32802   arg1 = (Dali::Layer *)jarg1;
32803   {
32804     try {
32805       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
32806     } catch (std::out_of_range& e) {
32807       {
32808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32809       };
32810     } catch (std::exception& e) {
32811       {
32812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32813       };
32814     } catch (...) {
32815       {
32816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32817       };
32818     }
32819   }
32820   jresult = result;
32821   return jresult;
32822 }
32823
32824
32825 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
32826   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32827   bool arg2 ;
32828
32829   arg1 = (Dali::Layer *)jarg1;
32830   arg2 = jarg2 ? true : false;
32831   {
32832     try {
32833       (arg1)->SetHoverConsumed(arg2);
32834     } catch (std::out_of_range& e) {
32835       {
32836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32837       };
32838     } catch (std::exception& e) {
32839       {
32840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32841       };
32842     } catch (...) {
32843       {
32844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32845       };
32846     }
32847   }
32848 }
32849
32850
32851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsHoverConsumed(void * jarg1) {
32852   unsigned int jresult ;
32853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32854   bool result;
32855
32856   arg1 = (Dali::Layer *)jarg1;
32857   {
32858     try {
32859       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
32860     } catch (std::out_of_range& e) {
32861       {
32862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32863       };
32864     } catch (std::exception& e) {
32865       {
32866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32867       };
32868     } catch (...) {
32869       {
32870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32871       };
32872     }
32873   }
32874   jresult = result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_DEFAULT_BACKGROUND_COLOR_get() {
32880   void * jresult ;
32881   Dali::Vector4 *result = 0 ;
32882
32883   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
32884   jresult = (void *)result;
32885   return jresult;
32886 }
32887
32888
32889 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_DEBUG_BACKGROUND_COLOR_get() {
32890   void * jresult ;
32891   Dali::Vector4 *result = 0 ;
32892
32893   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
32894   jresult = (void *)result;
32895   return jresult;
32896 }
32897
32898
32899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Stage__SWIG_0() {
32900   void * jresult ;
32901   Dali::Stage *result = 0 ;
32902
32903   {
32904     try {
32905       result = (Dali::Stage *)new Dali::Stage();
32906     } catch (std::out_of_range& e) {
32907       {
32908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32909       };
32910     } catch (std::exception& e) {
32911       {
32912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32913       };
32914     } catch (...) {
32915       {
32916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32917       };
32918     }
32919   }
32920   jresult = (void *)result;
32921   return jresult;
32922 }
32923
32924
32925 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetCurrent() {
32926   void * jresult ;
32927   Dali::Stage result;
32928
32929   {
32930     try {
32931       result = Dali::Stage::GetCurrent();
32932     } catch (std::out_of_range& e) {
32933       {
32934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32935       };
32936     } catch (std::exception& e) {
32937       {
32938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32939       };
32940     } catch (...) {
32941       {
32942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32943       };
32944     }
32945   }
32946   jresult = new Dali::Stage((const Dali::Stage &)result);
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Stage_IsInstalled() {
32952   unsigned int jresult ;
32953   bool result;
32954
32955   {
32956     try {
32957       result = (bool)Dali::Stage::IsInstalled();
32958     } catch (std::out_of_range& e) {
32959       {
32960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32961       };
32962     } catch (std::exception& e) {
32963       {
32964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32965       };
32966     } catch (...) {
32967       {
32968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32969       };
32970     }
32971   }
32972   jresult = result;
32973   return jresult;
32974 }
32975
32976
32977 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Stage(void * jarg1) {
32978   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
32979
32980   arg1 = (Dali::Stage *)jarg1;
32981   {
32982     try {
32983       delete arg1;
32984     } catch (std::out_of_range& e) {
32985       {
32986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32987       };
32988     } catch (std::exception& e) {
32989       {
32990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32991       };
32992     } catch (...) {
32993       {
32994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32995       };
32996     }
32997   }
32998 }
32999
33000
33001 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Stage__SWIG_1(void * jarg1) {
33002   void * jresult ;
33003   Dali::Stage *arg1 = 0 ;
33004   Dali::Stage *result = 0 ;
33005
33006   arg1 = (Dali::Stage *)jarg1;
33007   if (!arg1) {
33008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33009     return 0;
33010   }
33011   {
33012     try {
33013       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33014     } catch (std::out_of_range& e) {
33015       {
33016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33017       };
33018     } catch (std::exception& e) {
33019       {
33020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33021       };
33022     } catch (...) {
33023       {
33024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33025       };
33026     }
33027   }
33028   jresult = (void *)result;
33029   return jresult;
33030 }
33031
33032
33033 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_Assign(void * jarg1, void * jarg2) {
33034   void * jresult ;
33035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33036   Dali::Stage *arg2 = 0 ;
33037   Dali::Stage *result = 0 ;
33038
33039   arg1 = (Dali::Stage *)jarg1;
33040   arg2 = (Dali::Stage *)jarg2;
33041   if (!arg2) {
33042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33043     return 0;
33044   }
33045   {
33046     try {
33047       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33048     } catch (std::out_of_range& e) {
33049       {
33050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33051       };
33052     } catch (std::exception& e) {
33053       {
33054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33055       };
33056     } catch (...) {
33057       {
33058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33059       };
33060     }
33061   }
33062   jresult = (void *)result;
33063   return jresult;
33064 }
33065
33066
33067 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_Add(void * jarg1, void * jarg2) {
33068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33069   Dali::Actor *arg2 = 0 ;
33070
33071   arg1 = (Dali::Stage *)jarg1;
33072   arg2 = (Dali::Actor *)jarg2;
33073   if (!arg2) {
33074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33075     return ;
33076   }
33077   {
33078     try {
33079       (arg1)->Add(*arg2);
33080     } catch (std::out_of_range& e) {
33081       {
33082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33083       };
33084     } catch (std::exception& e) {
33085       {
33086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33087       };
33088     } catch (...) {
33089       {
33090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33091       };
33092     }
33093   }
33094 }
33095
33096
33097 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_Remove(void * jarg1, void * jarg2) {
33098   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33099   Dali::Actor *arg2 = 0 ;
33100
33101   arg1 = (Dali::Stage *)jarg1;
33102   arg2 = (Dali::Actor *)jarg2;
33103   if (!arg2) {
33104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33105     return ;
33106   }
33107   {
33108     try {
33109       (arg1)->Remove(*arg2);
33110     } catch (std::out_of_range& e) {
33111       {
33112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33113       };
33114     } catch (std::exception& e) {
33115       {
33116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33117       };
33118     } catch (...) {
33119       {
33120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33121       };
33122     }
33123   }
33124 }
33125
33126
33127 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetSize(void * jarg1) {
33128   void * jresult ;
33129   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33130   Dali::Vector2 result;
33131
33132   arg1 = (Dali::Stage *)jarg1;
33133   {
33134     try {
33135       result = ((Dali::Stage const *)arg1)->GetSize();
33136     } catch (std::out_of_range& e) {
33137       {
33138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33139       };
33140     } catch (std::exception& e) {
33141       {
33142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33143       };
33144     } catch (...) {
33145       {
33146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33147       };
33148     }
33149   }
33150   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33151   return jresult;
33152 }
33153
33154
33155 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetRenderTaskList(void * jarg1) {
33156   void * jresult ;
33157   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33158   Dali::RenderTaskList result;
33159
33160   arg1 = (Dali::Stage *)jarg1;
33161   {
33162     try {
33163       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33164     } catch (std::out_of_range& e) {
33165       {
33166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33167       };
33168     } catch (std::exception& e) {
33169       {
33170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33171       };
33172     } catch (...) {
33173       {
33174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33175       };
33176     }
33177   }
33178   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33179   return jresult;
33180 }
33181
33182
33183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Stage_GetLayerCount(void * jarg1) {
33184   unsigned int jresult ;
33185   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33186   unsigned int result;
33187
33188   arg1 = (Dali::Stage *)jarg1;
33189   {
33190     try {
33191       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33192     } catch (std::out_of_range& e) {
33193       {
33194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33195       };
33196     } catch (std::exception& e) {
33197       {
33198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33199       };
33200     } catch (...) {
33201       {
33202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33203       };
33204     }
33205   }
33206   jresult = result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33212   void * jresult ;
33213   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33214   unsigned int arg2 ;
33215   Dali::Layer result;
33216
33217   arg1 = (Dali::Stage *)jarg1;
33218   arg2 = (unsigned int)jarg2;
33219   {
33220     try {
33221       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33222     } catch (std::out_of_range& e) {
33223       {
33224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33225       };
33226     } catch (std::exception& e) {
33227       {
33228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33229       };
33230     } catch (...) {
33231       {
33232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33233       };
33234     }
33235   }
33236   jresult = new Dali::Layer((const Dali::Layer &)result);
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetRootLayer(void * jarg1) {
33242   void * jresult ;
33243   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33244   Dali::Layer result;
33245
33246   arg1 = (Dali::Stage *)jarg1;
33247   {
33248     try {
33249       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33250     } catch (std::out_of_range& e) {
33251       {
33252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33253       };
33254     } catch (std::exception& e) {
33255       {
33256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33257       };
33258     } catch (...) {
33259       {
33260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33261       };
33262     }
33263   }
33264   jresult = new Dali::Layer((const Dali::Layer &)result);
33265   return jresult;
33266 }
33267
33268
33269 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33270   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33271   Dali::Vector4 arg2 ;
33272   Dali::Vector4 *argp2 ;
33273
33274   arg1 = (Dali::Stage *)jarg1;
33275   argp2 = (Dali::Vector4 *)jarg2;
33276   if (!argp2) {
33277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33278     return ;
33279   }
33280   arg2 = *argp2;
33281   {
33282     try {
33283       (arg1)->SetBackgroundColor(arg2);
33284     } catch (std::out_of_range& e) {
33285       {
33286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33287       };
33288     } catch (std::exception& e) {
33289       {
33290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33291       };
33292     } catch (...) {
33293       {
33294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33295       };
33296     }
33297   }
33298 }
33299
33300
33301 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetBackgroundColor(void * jarg1) {
33302   void * jresult ;
33303   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33304   Dali::Vector4 result;
33305
33306   arg1 = (Dali::Stage *)jarg1;
33307   {
33308     try {
33309       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33310     } catch (std::out_of_range& e) {
33311       {
33312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33313       };
33314     } catch (std::exception& e) {
33315       {
33316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33317       };
33318     } catch (...) {
33319       {
33320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33321       };
33322     }
33323   }
33324   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetDpi(void * jarg1) {
33330   void * jresult ;
33331   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33332   Dali::Vector2 result;
33333
33334   arg1 = (Dali::Stage *)jarg1;
33335   {
33336     try {
33337       result = ((Dali::Stage const *)arg1)->GetDpi();
33338     } catch (std::out_of_range& e) {
33339       {
33340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33341       };
33342     } catch (std::exception& e) {
33343       {
33344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33345       };
33346     } catch (...) {
33347       {
33348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33349       };
33350     }
33351   }
33352   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33353   return jresult;
33354 }
33355
33356
33357 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetObjectRegistry(void * jarg1) {
33358   void * jresult ;
33359   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33360   Dali::ObjectRegistry result;
33361
33362   arg1 = (Dali::Stage *)jarg1;
33363   {
33364     try {
33365       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33366     } catch (std::out_of_range& e) {
33367       {
33368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33369       };
33370     } catch (std::exception& e) {
33371       {
33372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33373       };
33374     } catch (...) {
33375       {
33376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33377       };
33378     }
33379   }
33380   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33381   return jresult;
33382 }
33383
33384
33385 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_KeepRendering(void * jarg1, float jarg2) {
33386   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33387   float arg2 ;
33388
33389   arg1 = (Dali::Stage *)jarg1;
33390   arg2 = (float)jarg2;
33391   {
33392     try {
33393       (arg1)->KeepRendering(arg2);
33394     } catch (std::out_of_range& e) {
33395       {
33396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33397       };
33398     } catch (std::exception& e) {
33399       {
33400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33401       };
33402     } catch (...) {
33403       {
33404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33405       };
33406     }
33407   }
33408 }
33409
33410
33411 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_KeyEventSignal(void * jarg1) {
33412   void * jresult ;
33413   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33414   Dali::Stage::KeyEventSignalType *result = 0 ;
33415
33416   arg1 = (Dali::Stage *)jarg1;
33417   {
33418     try {
33419       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33420     } catch (std::out_of_range& e) {
33421       {
33422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33423       };
33424     } catch (std::exception& e) {
33425       {
33426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33427       };
33428     } catch (...) {
33429       {
33430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33431       };
33432     }
33433   }
33434   jresult = (void *)result;
33435   return jresult;
33436 }
33437
33438
33439 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_EventProcessingFinishedSignal(void * jarg1) {
33440   void * jresult ;
33441   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33442   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33443
33444   arg1 = (Dali::Stage *)jarg1;
33445   {
33446     try {
33447       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33448     } catch (std::out_of_range& e) {
33449       {
33450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33451       };
33452     } catch (std::exception& e) {
33453       {
33454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33459       };
33460     }
33461   }
33462   jresult = (void *)result;
33463   return jresult;
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_TouchedSignal(void * jarg1) {
33468   void * jresult ;
33469   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33470   Dali::Stage::TouchedSignalType *result = 0 ;
33471
33472   arg1 = (Dali::Stage *)jarg1;
33473   {
33474     try {
33475       result = (Dali::Stage::TouchedSignalType *) &(arg1)->TouchedSignal();
33476     } catch (std::out_of_range& e) {
33477       {
33478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (std::exception& e) {
33481       {
33482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33483       };
33484     } catch (...) {
33485       {
33486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33487       };
33488     }
33489   }
33490   jresult = (void *)result;
33491   return jresult;
33492 }
33493
33494
33495 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_TouchSignal(void * jarg1) {
33496   void * jresult ;
33497   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33498   Dali::Stage::TouchSignalType *result = 0 ;
33499
33500   arg1 = (Dali::Stage *)jarg1;
33501   {
33502     try {
33503       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33504     } catch (std::out_of_range& e) {
33505       {
33506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33507       };
33508     } catch (std::exception& e) {
33509       {
33510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33511       };
33512     } catch (...) {
33513       {
33514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33515       };
33516     }
33517   }
33518   jresult = (void *)result;
33519   return jresult;
33520 }
33521
33522
33523 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_WheelEventSignal(void * jarg1) {
33524   void * jresult ;
33525   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33526   Dali::Stage::WheelEventSignalType *result = 0 ;
33527
33528   arg1 = (Dali::Stage *)jarg1;
33529   {
33530     try {
33531       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33532     } catch (std::out_of_range& e) {
33533       {
33534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (std::exception& e) {
33537       {
33538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546   jresult = (void *)result;
33547   return jresult;
33548 }
33549
33550
33551 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_ContextLostSignal(void * jarg1) {
33552   void * jresult ;
33553   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33554   Dali::Stage::ContextStatusSignal *result = 0 ;
33555
33556   arg1 = (Dali::Stage *)jarg1;
33557   {
33558     try {
33559       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33560     } catch (std::out_of_range& e) {
33561       {
33562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33563       };
33564     } catch (std::exception& e) {
33565       {
33566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33567       };
33568     } catch (...) {
33569       {
33570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33571       };
33572     }
33573   }
33574   jresult = (void *)result;
33575   return jresult;
33576 }
33577
33578
33579 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_ContextRegainedSignal(void * jarg1) {
33580   void * jresult ;
33581   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33582   Dali::Stage::ContextStatusSignal *result = 0 ;
33583
33584   arg1 = (Dali::Stage *)jarg1;
33585   {
33586     try {
33587       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33588     } catch (std::out_of_range& e) {
33589       {
33590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33591       };
33592     } catch (std::exception& e) {
33593       {
33594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33595       };
33596     } catch (...) {
33597       {
33598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33599       };
33600     }
33601   }
33602   jresult = (void *)result;
33603   return jresult;
33604 }
33605
33606
33607 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_SceneCreatedSignal(void * jarg1) {
33608   void * jresult ;
33609   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33610   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33611
33612   arg1 = (Dali::Stage *)jarg1;
33613   {
33614     try {
33615       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33616     } catch (std::out_of_range& e) {
33617       {
33618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33619       };
33620     } catch (std::exception& e) {
33621       {
33622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33623       };
33624     } catch (...) {
33625       {
33626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33627       };
33628     }
33629   }
33630   jresult = (void *)result;
33631   return jresult;
33632 }
33633
33634
33635 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RelayoutContainer(void * jarg1) {
33636   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33637
33638   arg1 = (Dali::RelayoutContainer *)jarg1;
33639   {
33640     try {
33641       delete arg1;
33642     } catch (std::out_of_range& e) {
33643       {
33644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33645       };
33646     } catch (std::exception& e) {
33647       {
33648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33649       };
33650     } catch (...) {
33651       {
33652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33653       };
33654     }
33655   }
33656 }
33657
33658
33659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
33660   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33661   Dali::Actor *arg2 = 0 ;
33662   Dali::Vector2 *arg3 = 0 ;
33663
33664   arg1 = (Dali::RelayoutContainer *)jarg1;
33665   arg2 = (Dali::Actor *)jarg2;
33666   if (!arg2) {
33667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33668     return ;
33669   }
33670   arg3 = (Dali::Vector2 *)jarg3;
33671   if (!arg3) {
33672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33673     return ;
33674   }
33675   {
33676     try {
33677       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
33678     } catch (std::out_of_range& e) {
33679       {
33680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33681       };
33682     } catch (std::exception& e) {
33683       {
33684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33685       };
33686     } catch (...) {
33687       {
33688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33689       };
33690     }
33691   }
33692 }
33693
33694
33695 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActorImpl_Self(void * jarg1) {
33696   void * jresult ;
33697   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33698   Dali::CustomActor result;
33699
33700   arg1 = (Dali::CustomActorImpl *)jarg1;
33701   {
33702     try {
33703       result = ((Dali::CustomActorImpl const *)arg1)->Self();
33704     } catch (std::out_of_range& e) {
33705       {
33706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33707       };
33708     } catch (std::exception& e) {
33709       {
33710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33711       };
33712     } catch (...) {
33713       {
33714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33715       };
33716     }
33717   }
33718   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
33719   return jresult;
33720 }
33721
33722
33723 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
33724   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33725   int arg2 ;
33726
33727   arg1 = (Dali::CustomActorImpl *)jarg1;
33728   arg2 = (int)jarg2;
33729   {
33730     try {
33731       (arg1)->OnStageConnection(arg2);
33732     } catch (std::out_of_range& e) {
33733       {
33734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33735       };
33736     } catch (std::exception& e) {
33737       {
33738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33739       };
33740     } catch (...) {
33741       {
33742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33743       };
33744     }
33745   }
33746 }
33747
33748
33749 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnStageDisconnection(void * jarg1) {
33750   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33751
33752   arg1 = (Dali::CustomActorImpl *)jarg1;
33753   {
33754     try {
33755       (arg1)->OnStageDisconnection();
33756     } catch (std::out_of_range& e) {
33757       {
33758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33759       };
33760     } catch (std::exception& e) {
33761       {
33762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33763       };
33764     } catch (...) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33767       };
33768     }
33769   }
33770 }
33771
33772
33773 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
33774   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33775   Dali::Actor *arg2 = 0 ;
33776
33777   arg1 = (Dali::CustomActorImpl *)jarg1;
33778   arg2 = (Dali::Actor *)jarg2;
33779   if (!arg2) {
33780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33781     return ;
33782   }
33783   {
33784     try {
33785       (arg1)->OnChildAdd(*arg2);
33786     } catch (std::out_of_range& e) {
33787       {
33788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33789       };
33790     } catch (std::exception& e) {
33791       {
33792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33797       };
33798     }
33799   }
33800 }
33801
33802
33803 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
33804   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33805   Dali::Actor *arg2 = 0 ;
33806
33807   arg1 = (Dali::CustomActorImpl *)jarg1;
33808   arg2 = (Dali::Actor *)jarg2;
33809   if (!arg2) {
33810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33811     return ;
33812   }
33813   {
33814     try {
33815       (arg1)->OnChildRemove(*arg2);
33816     } catch (std::out_of_range& e) {
33817       {
33818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33819       };
33820     } catch (std::exception& e) {
33821       {
33822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33823       };
33824     } catch (...) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33827       };
33828     }
33829   }
33830 }
33831
33832
33833 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
33834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33835   Dali::Property::Index arg2 ;
33836   Dali::Property::Value arg3 ;
33837   Dali::Property::Value *argp3 ;
33838
33839   arg1 = (Dali::CustomActorImpl *)jarg1;
33840   arg2 = (Dali::Property::Index)jarg2;
33841   argp3 = (Dali::Property::Value *)jarg3;
33842   if (!argp3) {
33843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
33844     return ;
33845   }
33846   arg3 = *argp3;
33847   {
33848     try {
33849       (arg1)->OnPropertySet(arg2,arg3);
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33857       };
33858     } catch (...) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33861       };
33862     }
33863   }
33864 }
33865
33866
33867 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
33868   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33869   Dali::Vector3 *arg2 = 0 ;
33870
33871   arg1 = (Dali::CustomActorImpl *)jarg1;
33872   arg2 = (Dali::Vector3 *)jarg2;
33873   if (!arg2) {
33874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33875     return ;
33876   }
33877   {
33878     try {
33879       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33887       };
33888     } catch (...) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33891       };
33892     }
33893   }
33894 }
33895
33896
33897 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
33898   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33899   Dali::Animation *arg2 = 0 ;
33900   Dali::Vector3 *arg3 = 0 ;
33901
33902   arg1 = (Dali::CustomActorImpl *)jarg1;
33903   arg2 = (Dali::Animation *)jarg2;
33904   if (!arg2) {
33905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
33906     return ;
33907   }
33908   arg3 = (Dali::Vector3 *)jarg3;
33909   if (!arg3) {
33910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33911     return ;
33912   }
33913   {
33914     try {
33915       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
33916     } catch (std::out_of_range& e) {
33917       {
33918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33919       };
33920     } catch (std::exception& e) {
33921       {
33922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33923       };
33924     } catch (...) {
33925       {
33926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33927       };
33928     }
33929   }
33930 }
33931
33932
33933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
33934   unsigned int jresult ;
33935   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33936   Dali::TouchEvent *arg2 = 0 ;
33937   bool result;
33938
33939   arg1 = (Dali::CustomActorImpl *)jarg1;
33940   arg2 = (Dali::TouchEvent *)jarg2;
33941   if (!arg2) {
33942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33943     return 0;
33944   }
33945   {
33946     try {
33947       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
33948     } catch (std::out_of_range& e) {
33949       {
33950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33951       };
33952     } catch (std::exception& e) {
33953       {
33954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33955       };
33956     } catch (...) {
33957       {
33958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33959       };
33960     }
33961   }
33962   jresult = result;
33963   return jresult;
33964 }
33965
33966
33967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
33968   unsigned int jresult ;
33969   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33970   Dali::HoverEvent *arg2 = 0 ;
33971   bool result;
33972
33973   arg1 = (Dali::CustomActorImpl *)jarg1;
33974   arg2 = (Dali::HoverEvent *)jarg2;
33975   if (!arg2) {
33976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
33977     return 0;
33978   }
33979   {
33980     try {
33981       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
33982     } catch (std::out_of_range& e) {
33983       {
33984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33985       };
33986     } catch (std::exception& e) {
33987       {
33988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (...) {
33991       {
33992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33993       };
33994     }
33995   }
33996   jresult = result;
33997   return jresult;
33998 }
33999
34000
34001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34002   unsigned int jresult ;
34003   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34004   Dali::KeyEvent *arg2 = 0 ;
34005   bool result;
34006
34007   arg1 = (Dali::CustomActorImpl *)jarg1;
34008   arg2 = (Dali::KeyEvent *)jarg2;
34009   if (!arg2) {
34010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34011     return 0;
34012   }
34013   {
34014     try {
34015       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34016     } catch (std::out_of_range& e) {
34017       {
34018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34019       };
34020     } catch (std::exception& e) {
34021       {
34022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (...) {
34025       {
34026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34027       };
34028     }
34029   }
34030   jresult = result;
34031   return jresult;
34032 }
34033
34034
34035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34036   unsigned int jresult ;
34037   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34038   Dali::WheelEvent *arg2 = 0 ;
34039   bool result;
34040
34041   arg1 = (Dali::CustomActorImpl *)jarg1;
34042   arg2 = (Dali::WheelEvent *)jarg2;
34043   if (!arg2) {
34044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34045     return 0;
34046   }
34047   {
34048     try {
34049       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34050     } catch (std::out_of_range& e) {
34051       {
34052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34053       };
34054     } catch (std::exception& e) {
34055       {
34056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34057       };
34058     } catch (...) {
34059       {
34060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34061       };
34062     }
34063   }
34064   jresult = result;
34065   return jresult;
34066 }
34067
34068
34069 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34070   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34071   Dali::Vector2 *arg2 = 0 ;
34072   Dali::RelayoutContainer *arg3 = 0 ;
34073
34074   arg1 = (Dali::CustomActorImpl *)jarg1;
34075   arg2 = (Dali::Vector2 *)jarg2;
34076   if (!arg2) {
34077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34078     return ;
34079   }
34080   arg3 = (Dali::RelayoutContainer *)jarg3;
34081   if (!arg3) {
34082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34083     return ;
34084   }
34085   {
34086     try {
34087       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34088     } catch (std::out_of_range& e) {
34089       {
34090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34091       };
34092     } catch (std::exception& e) {
34093       {
34094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34095       };
34096     } catch (...) {
34097       {
34098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34099       };
34100     }
34101   }
34102 }
34103
34104
34105 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34106   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34107   Dali::ResizePolicy::Type arg2 ;
34108   Dali::Dimension::Type arg3 ;
34109
34110   arg1 = (Dali::CustomActorImpl *)jarg1;
34111   arg2 = (Dali::ResizePolicy::Type)jarg2;
34112   arg3 = (Dali::Dimension::Type)jarg3;
34113   {
34114     try {
34115       (arg1)->OnSetResizePolicy(arg2,arg3);
34116     } catch (std::out_of_range& e) {
34117       {
34118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34119       };
34120     } catch (std::exception& e) {
34121       {
34122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34127       };
34128     }
34129   }
34130 }
34131
34132
34133 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetNaturalSize(void * jarg1) {
34134   void * jresult ;
34135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34136   Dali::Vector3 result;
34137
34138   arg1 = (Dali::CustomActorImpl *)jarg1;
34139   {
34140     try {
34141       result = (arg1)->GetNaturalSize();
34142     } catch (std::out_of_range& e) {
34143       {
34144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34145       };
34146     } catch (std::exception& e) {
34147       {
34148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34153       };
34154     }
34155   }
34156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34162   float jresult ;
34163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34164   Dali::Actor *arg2 = 0 ;
34165   Dali::Dimension::Type arg3 ;
34166   float result;
34167
34168   arg1 = (Dali::CustomActorImpl *)jarg1;
34169   arg2 = (Dali::Actor *)jarg2;
34170   if (!arg2) {
34171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34172     return 0;
34173   }
34174   arg3 = (Dali::Dimension::Type)jarg3;
34175   {
34176     try {
34177       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34178     } catch (std::out_of_range& e) {
34179       {
34180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34181       };
34182     } catch (std::exception& e) {
34183       {
34184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34185       };
34186     } catch (...) {
34187       {
34188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34189       };
34190     }
34191   }
34192   jresult = result;
34193   return jresult;
34194 }
34195
34196
34197 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34198   float jresult ;
34199   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34200   float arg2 ;
34201   float result;
34202
34203   arg1 = (Dali::CustomActorImpl *)jarg1;
34204   arg2 = (float)jarg2;
34205   {
34206     try {
34207       result = (float)(arg1)->GetHeightForWidth(arg2);
34208     } catch (std::out_of_range& e) {
34209       {
34210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34211       };
34212     } catch (std::exception& e) {
34213       {
34214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34215       };
34216     } catch (...) {
34217       {
34218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34219       };
34220     }
34221   }
34222   jresult = result;
34223   return jresult;
34224 }
34225
34226
34227 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34228   float jresult ;
34229   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34230   float arg2 ;
34231   float result;
34232
34233   arg1 = (Dali::CustomActorImpl *)jarg1;
34234   arg2 = (float)jarg2;
34235   {
34236     try {
34237       result = (float)(arg1)->GetWidthForHeight(arg2);
34238     } catch (std::out_of_range& e) {
34239       {
34240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34241       };
34242     } catch (std::exception& e) {
34243       {
34244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34245       };
34246     } catch (...) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34249       };
34250     }
34251   }
34252   jresult = result;
34253   return jresult;
34254 }
34255
34256
34257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34258   unsigned int jresult ;
34259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34260   Dali::Dimension::Type arg2 ;
34261   bool result;
34262
34263   arg1 = (Dali::CustomActorImpl *)jarg1;
34264   arg2 = (Dali::Dimension::Type)jarg2;
34265   {
34266     try {
34267       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (...) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34279       };
34280     }
34281   }
34282   jresult = result;
34283   return jresult;
34284 }
34285
34286
34287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34288   unsigned int jresult ;
34289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34290   bool result;
34291
34292   arg1 = (Dali::CustomActorImpl *)jarg1;
34293   {
34294     try {
34295       result = (bool)(arg1)->RelayoutDependentOnChildren();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (...) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34307       };
34308     }
34309   }
34310   jresult = result;
34311   return jresult;
34312 }
34313
34314
34315 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34316   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34317   Dali::Dimension::Type arg2 ;
34318
34319   arg1 = (Dali::CustomActorImpl *)jarg1;
34320   arg2 = (Dali::Dimension::Type)jarg2;
34321   {
34322     try {
34323       (arg1)->OnCalculateRelayoutSize(arg2);
34324     } catch (std::out_of_range& e) {
34325       {
34326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34327       };
34328     } catch (std::exception& e) {
34329       {
34330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34331       };
34332     } catch (...) {
34333       {
34334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34335       };
34336     }
34337   }
34338 }
34339
34340
34341 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34342   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34343   float arg2 ;
34344   Dali::Dimension::Type arg3 ;
34345
34346   arg1 = (Dali::CustomActorImpl *)jarg1;
34347   arg2 = (float)jarg2;
34348   arg3 = (Dali::Dimension::Type)jarg3;
34349   {
34350     try {
34351       (arg1)->OnLayoutNegotiated(arg2,arg3);
34352     } catch (std::out_of_range& e) {
34353       {
34354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34355       };
34356     } catch (std::exception& e) {
34357       {
34358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34359       };
34360     } catch (...) {
34361       {
34362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34363       };
34364     }
34365   }
34366 }
34367
34368
34369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34370   unsigned int jresult ;
34371   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34372   bool result;
34373
34374   arg1 = (Dali::CustomActorImpl *)jarg1;
34375   {
34376     try {
34377       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34378     } catch (std::out_of_range& e) {
34379       {
34380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34381       };
34382     } catch (std::exception& e) {
34383       {
34384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34385       };
34386     } catch (...) {
34387       {
34388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34389       };
34390     }
34391   }
34392   jresult = result;
34393   return jresult;
34394 }
34395
34396
34397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34398   unsigned int jresult ;
34399   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34400   bool result;
34401
34402   arg1 = (Dali::CustomActorImpl *)jarg1;
34403   {
34404     try {
34405       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34406     } catch (std::out_of_range& e) {
34407       {
34408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34409       };
34410     } catch (std::exception& e) {
34411       {
34412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34413       };
34414     } catch (...) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34417       };
34418     }
34419   }
34420   jresult = result;
34421   return jresult;
34422 }
34423
34424
34425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34426   unsigned int jresult ;
34427   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34428   bool result;
34429
34430   arg1 = (Dali::CustomActorImpl *)jarg1;
34431   {
34432     try {
34433       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34441       };
34442     } catch (...) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34445       };
34446     }
34447   }
34448   jresult = result;
34449   return jresult;
34450 }
34451
34452
34453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34454   unsigned int jresult ;
34455   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34456   bool result;
34457
34458   arg1 = (Dali::CustomActorImpl *)jarg1;
34459   {
34460     try {
34461       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34462     } catch (std::out_of_range& e) {
34463       {
34464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34465       };
34466     } catch (std::exception& e) {
34467       {
34468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34469       };
34470     } catch (...) {
34471       {
34472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34473       };
34474     }
34475   }
34476   jresult = result;
34477   return jresult;
34478 }
34479
34480
34481 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_0() {
34482   void * jresult ;
34483   Dali::CustomActor *result = 0 ;
34484
34485   {
34486     try {
34487       result = (Dali::CustomActor *)new Dali::CustomActor();
34488     } catch (std::out_of_range& e) {
34489       {
34490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34491       };
34492     } catch (std::exception& e) {
34493       {
34494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34495       };
34496     } catch (...) {
34497       {
34498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34499       };
34500     }
34501   }
34502   jresult = (void *)result;
34503   return jresult;
34504 }
34505
34506
34507 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_DownCast(void * jarg1) {
34508   void * jresult ;
34509   Dali::BaseHandle arg1 ;
34510   Dali::BaseHandle *argp1 ;
34511   Dali::CustomActor result;
34512
34513   argp1 = (Dali::BaseHandle *)jarg1;
34514   if (!argp1) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34516     return 0;
34517   }
34518   arg1 = *argp1;
34519   {
34520     try {
34521       result = Dali::CustomActor::DownCast(arg1);
34522     } catch (std::out_of_range& e) {
34523       {
34524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34525       };
34526     } catch (std::exception& e) {
34527       {
34528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34529       };
34530     } catch (...) {
34531       {
34532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34533       };
34534     }
34535   }
34536   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34537   return jresult;
34538 }
34539
34540
34541 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CustomActor(void * jarg1) {
34542   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34543
34544   arg1 = (Dali::CustomActor *)jarg1;
34545   {
34546     try {
34547       delete arg1;
34548     } catch (std::out_of_range& e) {
34549       {
34550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (std::exception& e) {
34553       {
34554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34555       };
34556     } catch (...) {
34557       {
34558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34559       };
34560     }
34561   }
34562 }
34563
34564
34565 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_GetImplementation(void * jarg1) {
34566   void * jresult ;
34567   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34568   Dali::CustomActorImpl *result = 0 ;
34569
34570   arg1 = (Dali::CustomActor *)jarg1;
34571   {
34572     try {
34573       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34581       };
34582     } catch (...) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34585       };
34586     }
34587   }
34588   jresult = (void *)result;
34589   return jresult;
34590 }
34591
34592
34593 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_1(void * jarg1) {
34594   void * jresult ;
34595   Dali::CustomActorImpl *arg1 = 0 ;
34596   Dali::CustomActor *result = 0 ;
34597
34598   arg1 = (Dali::CustomActorImpl *)jarg1;
34599   if (!arg1) {
34600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34601     return 0;
34602   }
34603   {
34604     try {
34605       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34606     } catch (std::out_of_range& e) {
34607       {
34608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34609       };
34610     } catch (std::exception& e) {
34611       {
34612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34613       };
34614     } catch (...) {
34615       {
34616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34617       };
34618     }
34619   }
34620   jresult = (void *)result;
34621   return jresult;
34622 }
34623
34624
34625 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_2(void * jarg1) {
34626   void * jresult ;
34627   Dali::CustomActor *arg1 = 0 ;
34628   Dali::CustomActor *result = 0 ;
34629
34630   arg1 = (Dali::CustomActor *)jarg1;
34631   if (!arg1) {
34632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34633     return 0;
34634   }
34635   {
34636     try {
34637       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34638     } catch (std::out_of_range& e) {
34639       {
34640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34641       };
34642     } catch (std::exception& e) {
34643       {
34644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34645       };
34646     } catch (...) {
34647       {
34648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34649       };
34650     }
34651   }
34652   jresult = (void *)result;
34653   return jresult;
34654 }
34655
34656
34657 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_Assign(void * jarg1, void * jarg2) {
34658   void * jresult ;
34659   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34660   Dali::CustomActor *arg2 = 0 ;
34661   Dali::CustomActor *result = 0 ;
34662
34663   arg1 = (Dali::CustomActor *)jarg1;
34664   arg2 = (Dali::CustomActor *)jarg2;
34665   if (!arg2) {
34666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34667     return 0;
34668   }
34669   {
34670     try {
34671       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34679       };
34680     } catch (...) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34683       };
34684     }
34685   }
34686   jresult = (void *)result;
34687   return jresult;
34688 }
34689
34690
34691 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_POSITION_get() {
34692   int jresult ;
34693   int result;
34694
34695   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
34696   jresult = (int)result;
34697   return jresult;
34698 }
34699
34700
34701 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
34702   int jresult ;
34703   int result;
34704
34705   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
34706   jresult = (int)result;
34707   return jresult;
34708 }
34709
34710
34711 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
34712   int jresult ;
34713   int result;
34714
34715   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
34716   jresult = (int)result;
34717   return jresult;
34718 }
34719
34720
34721 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_POSITION_get() {
34722   int jresult ;
34723   int result;
34724
34725   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
34726   jresult = (int)result;
34727   return jresult;
34728 }
34729
34730
34731 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
34732   int jresult ;
34733   int result;
34734
34735   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
34736   jresult = (int)result;
34737   return jresult;
34738 }
34739
34740
34741 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
34742   int jresult ;
34743   int result;
34744
34745   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
34746   jresult = (int)result;
34747   return jresult;
34748 }
34749
34750
34751 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_PANNING_get() {
34752   int jresult ;
34753   int result;
34754
34755   result = (int)Dali::PanGestureDetector::Property::PANNING;
34756   jresult = (int)result;
34757   return jresult;
34758 }
34759
34760
34761 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector_Property() {
34762   void * jresult ;
34763   Dali::PanGestureDetector::Property *result = 0 ;
34764
34765   {
34766     try {
34767       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34775       };
34776     } catch (...) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34779       };
34780     }
34781   }
34782   jresult = (void *)result;
34783   return jresult;
34784 }
34785
34786
34787 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetector_Property(void * jarg1) {
34788   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
34789
34790   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
34791   {
34792     try {
34793       delete arg1;
34794     } catch (std::out_of_range& e) {
34795       {
34796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34797       };
34798     } catch (std::exception& e) {
34799       {
34800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34801       };
34802     } catch (...) {
34803       {
34804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34805       };
34806     }
34807   }
34808 }
34809
34810
34811 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_LEFT_get() {
34812   void * jresult ;
34813   Dali::Radian *result = 0 ;
34814
34815   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
34816   jresult = (void *)result;
34817   return jresult;
34818 }
34819
34820
34821 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_RIGHT_get() {
34822   void * jresult ;
34823   Dali::Radian *result = 0 ;
34824
34825   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
34826   jresult = (void *)result;
34827   return jresult;
34828 }
34829
34830
34831 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_UP_get() {
34832   void * jresult ;
34833   Dali::Radian *result = 0 ;
34834
34835   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
34836   jresult = (void *)result;
34837   return jresult;
34838 }
34839
34840
34841 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_DOWN_get() {
34842   void * jresult ;
34843   Dali::Radian *result = 0 ;
34844
34845   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
34846   jresult = (void *)result;
34847   return jresult;
34848 }
34849
34850
34851 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
34852   void * jresult ;
34853   Dali::Radian *result = 0 ;
34854
34855   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
34856   jresult = (void *)result;
34857   return jresult;
34858 }
34859
34860
34861 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_VERTICAL_get() {
34862   void * jresult ;
34863   Dali::Radian *result = 0 ;
34864
34865   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
34866   jresult = (void *)result;
34867   return jresult;
34868 }
34869
34870
34871 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DEFAULT_THRESHOLD_get() {
34872   void * jresult ;
34873   Dali::Radian *result = 0 ;
34874
34875   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
34876   jresult = (void *)result;
34877   return jresult;
34878 }
34879
34880
34881 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector__SWIG_0() {
34882   void * jresult ;
34883   Dali::PanGestureDetector *result = 0 ;
34884
34885   {
34886     try {
34887       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
34888     } catch (std::out_of_range& e) {
34889       {
34890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34891       };
34892     } catch (std::exception& e) {
34893       {
34894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34895       };
34896     } catch (...) {
34897       {
34898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34899       };
34900     }
34901   }
34902   jresult = (void *)result;
34903   return jresult;
34904 }
34905
34906
34907 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_New() {
34908   void * jresult ;
34909   Dali::PanGestureDetector result;
34910
34911   {
34912     try {
34913       result = Dali::PanGestureDetector::New();
34914     } catch (std::out_of_range& e) {
34915       {
34916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34917       };
34918     } catch (std::exception& e) {
34919       {
34920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34921       };
34922     } catch (...) {
34923       {
34924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34925       };
34926     }
34927   }
34928   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
34929   return jresult;
34930 }
34931
34932
34933 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DownCast(void * jarg1) {
34934   void * jresult ;
34935   Dali::BaseHandle arg1 ;
34936   Dali::BaseHandle *argp1 ;
34937   Dali::PanGestureDetector result;
34938
34939   argp1 = (Dali::BaseHandle *)jarg1;
34940   if (!argp1) {
34941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34942     return 0;
34943   }
34944   arg1 = *argp1;
34945   {
34946     try {
34947       result = Dali::PanGestureDetector::DownCast(arg1);
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34955       };
34956     } catch (...) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34959       };
34960     }
34961   }
34962   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
34963   return jresult;
34964 }
34965
34966
34967 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetector(void * jarg1) {
34968   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
34969
34970   arg1 = (Dali::PanGestureDetector *)jarg1;
34971   {
34972     try {
34973       delete arg1;
34974     } catch (std::out_of_range& e) {
34975       {
34976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34977       };
34978     } catch (std::exception& e) {
34979       {
34980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34981       };
34982     } catch (...) {
34983       {
34984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34985       };
34986     }
34987   }
34988 }
34989
34990
34991 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector__SWIG_1(void * jarg1) {
34992   void * jresult ;
34993   Dali::PanGestureDetector *arg1 = 0 ;
34994   Dali::PanGestureDetector *result = 0 ;
34995
34996   arg1 = (Dali::PanGestureDetector *)jarg1;
34997   if (!arg1) {
34998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
34999     return 0;
35000   }
35001   {
35002     try {
35003       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35004     } catch (std::out_of_range& e) {
35005       {
35006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35007       };
35008     } catch (std::exception& e) {
35009       {
35010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35011       };
35012     } catch (...) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35015       };
35016     }
35017   }
35018   jresult = (void *)result;
35019   return jresult;
35020 }
35021
35022
35023 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35024   void * jresult ;
35025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35026   Dali::PanGestureDetector *arg2 = 0 ;
35027   Dali::PanGestureDetector *result = 0 ;
35028
35029   arg1 = (Dali::PanGestureDetector *)jarg1;
35030   arg2 = (Dali::PanGestureDetector *)jarg2;
35031   if (!arg2) {
35032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35033     return 0;
35034   }
35035   {
35036     try {
35037       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35038     } catch (std::out_of_range& e) {
35039       {
35040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35041       };
35042     } catch (std::exception& e) {
35043       {
35044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35045       };
35046     } catch (...) {
35047       {
35048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35049       };
35050     }
35051   }
35052   jresult = (void *)result;
35053   return jresult;
35054 }
35055
35056
35057 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35058   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35059   unsigned int arg2 ;
35060
35061   arg1 = (Dali::PanGestureDetector *)jarg1;
35062   arg2 = (unsigned int)jarg2;
35063   {
35064     try {
35065       (arg1)->SetMinimumTouchesRequired(arg2);
35066     } catch (std::out_of_range& e) {
35067       {
35068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35069       };
35070     } catch (std::exception& e) {
35071       {
35072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35073       };
35074     } catch (...) {
35075       {
35076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35077       };
35078     }
35079   }
35080 }
35081
35082
35083 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35084   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35085   unsigned int arg2 ;
35086
35087   arg1 = (Dali::PanGestureDetector *)jarg1;
35088   arg2 = (unsigned int)jarg2;
35089   {
35090     try {
35091       (arg1)->SetMaximumTouchesRequired(arg2);
35092     } catch (std::out_of_range& e) {
35093       {
35094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35095       };
35096     } catch (std::exception& e) {
35097       {
35098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35099       };
35100     } catch (...) {
35101       {
35102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35103       };
35104     }
35105   }
35106 }
35107
35108
35109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35110   unsigned int jresult ;
35111   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35112   unsigned int result;
35113
35114   arg1 = (Dali::PanGestureDetector *)jarg1;
35115   {
35116     try {
35117       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35118     } catch (std::out_of_range& e) {
35119       {
35120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35121       };
35122     } catch (std::exception& e) {
35123       {
35124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35125       };
35126     } catch (...) {
35127       {
35128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35129       };
35130     }
35131   }
35132   jresult = result;
35133   return jresult;
35134 }
35135
35136
35137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35138   unsigned int jresult ;
35139   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35140   unsigned int result;
35141
35142   arg1 = (Dali::PanGestureDetector *)jarg1;
35143   {
35144     try {
35145       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35146     } catch (std::out_of_range& e) {
35147       {
35148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35149       };
35150     } catch (std::exception& e) {
35151       {
35152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35153       };
35154     } catch (...) {
35155       {
35156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35157       };
35158     }
35159   }
35160   jresult = result;
35161   return jresult;
35162 }
35163
35164
35165 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35166   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35167   Dali::Radian arg2 ;
35168   Dali::Radian arg3 ;
35169   Dali::Radian *argp2 ;
35170   Dali::Radian *argp3 ;
35171
35172   arg1 = (Dali::PanGestureDetector *)jarg1;
35173   argp2 = (Dali::Radian *)jarg2;
35174   if (!argp2) {
35175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35176     return ;
35177   }
35178   arg2 = *argp2;
35179   argp3 = (Dali::Radian *)jarg3;
35180   if (!argp3) {
35181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35182     return ;
35183   }
35184   arg3 = *argp3;
35185   {
35186     try {
35187       (arg1)->AddAngle(arg2,arg3);
35188     } catch (std::out_of_range& e) {
35189       {
35190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35191       };
35192     } catch (std::exception& e) {
35193       {
35194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35195       };
35196     } catch (...) {
35197       {
35198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35199       };
35200     }
35201   }
35202 }
35203
35204
35205 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35206   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35207   Dali::Radian arg2 ;
35208   Dali::Radian *argp2 ;
35209
35210   arg1 = (Dali::PanGestureDetector *)jarg1;
35211   argp2 = (Dali::Radian *)jarg2;
35212   if (!argp2) {
35213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35214     return ;
35215   }
35216   arg2 = *argp2;
35217   {
35218     try {
35219       (arg1)->AddAngle(arg2);
35220     } catch (std::out_of_range& e) {
35221       {
35222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35223       };
35224     } catch (std::exception& e) {
35225       {
35226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35227       };
35228     } catch (...) {
35229       {
35230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35231       };
35232     }
35233   }
35234 }
35235
35236
35237 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35238   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35239   Dali::Radian arg2 ;
35240   Dali::Radian arg3 ;
35241   Dali::Radian *argp2 ;
35242   Dali::Radian *argp3 ;
35243
35244   arg1 = (Dali::PanGestureDetector *)jarg1;
35245   argp2 = (Dali::Radian *)jarg2;
35246   if (!argp2) {
35247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35248     return ;
35249   }
35250   arg2 = *argp2;
35251   argp3 = (Dali::Radian *)jarg3;
35252   if (!argp3) {
35253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35254     return ;
35255   }
35256   arg3 = *argp3;
35257   {
35258     try {
35259       (arg1)->AddDirection(arg2,arg3);
35260     } catch (std::out_of_range& e) {
35261       {
35262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (std::exception& e) {
35265       {
35266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35267       };
35268     } catch (...) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35271       };
35272     }
35273   }
35274 }
35275
35276
35277 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35278   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35279   Dali::Radian arg2 ;
35280   Dali::Radian *argp2 ;
35281
35282   arg1 = (Dali::PanGestureDetector *)jarg1;
35283   argp2 = (Dali::Radian *)jarg2;
35284   if (!argp2) {
35285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35286     return ;
35287   }
35288   arg2 = *argp2;
35289   {
35290     try {
35291       (arg1)->AddDirection(arg2);
35292     } catch (std::out_of_range& e) {
35293       {
35294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35295       };
35296     } catch (std::exception& e) {
35297       {
35298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35299       };
35300     } catch (...) {
35301       {
35302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35303       };
35304     }
35305   }
35306 }
35307
35308
35309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetAngleCount(void * jarg1) {
35310   unsigned long jresult ;
35311   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35312   size_t result;
35313
35314   arg1 = (Dali::PanGestureDetector *)jarg1;
35315   {
35316     try {
35317       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35318     } catch (std::out_of_range& e) {
35319       {
35320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35321       };
35322     } catch (std::exception& e) {
35323       {
35324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35325       };
35326     } catch (...) {
35327       {
35328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35329       };
35330     }
35331   }
35332   jresult = (unsigned long)result;
35333   return jresult;
35334 }
35335
35336
35337 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35338   void * jresult ;
35339   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35340   size_t arg2 ;
35341   Dali::PanGestureDetector::AngleThresholdPair result;
35342
35343   arg1 = (Dali::PanGestureDetector *)jarg1;
35344   arg2 = (size_t)jarg2;
35345   {
35346     try {
35347       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35348     } catch (std::out_of_range& e) {
35349       {
35350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35351       };
35352     } catch (std::exception& e) {
35353       {
35354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35355       };
35356     } catch (...) {
35357       {
35358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35359       };
35360     }
35361   }
35362   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35363   return jresult;
35364 }
35365
35366
35367 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_ClearAngles(void * jarg1) {
35368   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35369
35370   arg1 = (Dali::PanGestureDetector *)jarg1;
35371   {
35372     try {
35373       (arg1)->ClearAngles();
35374     } catch (std::out_of_range& e) {
35375       {
35376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35377       };
35378     } catch (std::exception& e) {
35379       {
35380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35381       };
35382     } catch (...) {
35383       {
35384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35385       };
35386     }
35387   }
35388 }
35389
35390
35391 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35392   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35393   Dali::Radian arg2 ;
35394   Dali::Radian *argp2 ;
35395
35396   arg1 = (Dali::PanGestureDetector *)jarg1;
35397   argp2 = (Dali::Radian *)jarg2;
35398   if (!argp2) {
35399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35400     return ;
35401   }
35402   arg2 = *argp2;
35403   {
35404     try {
35405       (arg1)->RemoveAngle(arg2);
35406     } catch (std::out_of_range& e) {
35407       {
35408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35409       };
35410     } catch (std::exception& e) {
35411       {
35412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35413       };
35414     } catch (...) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35417       };
35418     }
35419   }
35420 }
35421
35422
35423 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35424   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35425   Dali::Radian arg2 ;
35426   Dali::Radian *argp2 ;
35427
35428   arg1 = (Dali::PanGestureDetector *)jarg1;
35429   argp2 = (Dali::Radian *)jarg2;
35430   if (!argp2) {
35431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35432     return ;
35433   }
35434   arg2 = *argp2;
35435   {
35436     try {
35437       (arg1)->RemoveDirection(arg2);
35438     } catch (std::out_of_range& e) {
35439       {
35440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35441       };
35442     } catch (std::exception& e) {
35443       {
35444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35445       };
35446     } catch (...) {
35447       {
35448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35449       };
35450     }
35451   }
35452 }
35453
35454
35455 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DetectedSignal(void * jarg1) {
35456   void * jresult ;
35457   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35458   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35459
35460   arg1 = (Dali::PanGestureDetector *)jarg1;
35461   {
35462     try {
35463       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35471       };
35472     } catch (...) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35475       };
35476     }
35477   }
35478   jresult = (void *)result;
35479   return jresult;
35480 }
35481
35482
35483 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35484   Dali::PanGesture *arg1 = 0 ;
35485
35486   arg1 = (Dali::PanGesture *)jarg1;
35487   if (!arg1) {
35488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35489     return ;
35490   }
35491   {
35492     try {
35493       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35501       };
35502     } catch (...) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35505       };
35506     }
35507   }
35508 }
35509
35510
35511 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_0() {
35512   void * jresult ;
35513   Dali::PanGesture *result = 0 ;
35514
35515   {
35516     try {
35517       result = (Dali::PanGesture *)new Dali::PanGesture();
35518     } catch (std::out_of_range& e) {
35519       {
35520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35521       };
35522     } catch (std::exception& e) {
35523       {
35524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35525       };
35526     } catch (...) {
35527       {
35528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35529       };
35530     }
35531   }
35532   jresult = (void *)result;
35533   return jresult;
35534 }
35535
35536
35537 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_1(int jarg1) {
35538   void * jresult ;
35539   Dali::Gesture::State arg1 ;
35540   Dali::PanGesture *result = 0 ;
35541
35542   arg1 = (Dali::Gesture::State)jarg1;
35543   {
35544     try {
35545       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35546     } catch (std::out_of_range& e) {
35547       {
35548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35549       };
35550     } catch (std::exception& e) {
35551       {
35552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35553       };
35554     } catch (...) {
35555       {
35556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35557       };
35558     }
35559   }
35560   jresult = (void *)result;
35561   return jresult;
35562 }
35563
35564
35565 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_2(void * jarg1) {
35566   void * jresult ;
35567   Dali::PanGesture *arg1 = 0 ;
35568   Dali::PanGesture *result = 0 ;
35569
35570   arg1 = (Dali::PanGesture *)jarg1;
35571   if (!arg1) {
35572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35573     return 0;
35574   }
35575   {
35576     try {
35577       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35578     } catch (std::out_of_range& e) {
35579       {
35580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35581       };
35582     } catch (std::exception& e) {
35583       {
35584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35585       };
35586     } catch (...) {
35587       {
35588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35589       };
35590     }
35591   }
35592   jresult = (void *)result;
35593   return jresult;
35594 }
35595
35596
35597 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_Assign(void * jarg1, void * jarg2) {
35598   void * jresult ;
35599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35600   Dali::PanGesture *arg2 = 0 ;
35601   Dali::PanGesture *result = 0 ;
35602
35603   arg1 = (Dali::PanGesture *)jarg1;
35604   arg2 = (Dali::PanGesture *)jarg2;
35605   if (!arg2) {
35606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35607     return 0;
35608   }
35609   {
35610     try {
35611       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35612     } catch (std::out_of_range& e) {
35613       {
35614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35615       };
35616     } catch (std::exception& e) {
35617       {
35618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35619       };
35620     } catch (...) {
35621       {
35622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35623       };
35624     }
35625   }
35626   jresult = (void *)result;
35627   return jresult;
35628 }
35629
35630
35631 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGesture(void * jarg1) {
35632   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35633
35634   arg1 = (Dali::PanGesture *)jarg1;
35635   {
35636     try {
35637       delete arg1;
35638     } catch (std::out_of_range& e) {
35639       {
35640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35641       };
35642     } catch (std::exception& e) {
35643       {
35644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35645       };
35646     } catch (...) {
35647       {
35648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35649       };
35650     }
35651   }
35652 }
35653
35654
35655 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35656   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35657   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35658
35659   arg1 = (Dali::PanGesture *)jarg1;
35660   arg2 = (Dali::Vector2 *)jarg2;
35661   if (arg1) (arg1)->velocity = *arg2;
35662 }
35663
35664
35665 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_velocity_get(void * jarg1) {
35666   void * jresult ;
35667   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35668   Dali::Vector2 *result = 0 ;
35669
35670   arg1 = (Dali::PanGesture *)jarg1;
35671   result = (Dali::Vector2 *)& ((arg1)->velocity);
35672   jresult = (void *)result;
35673   return jresult;
35674 }
35675
35676
35677 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_displacement_set(void * jarg1, void * jarg2) {
35678   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35679   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35680
35681   arg1 = (Dali::PanGesture *)jarg1;
35682   arg2 = (Dali::Vector2 *)jarg2;
35683   if (arg1) (arg1)->displacement = *arg2;
35684 }
35685
35686
35687 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_displacement_get(void * jarg1) {
35688   void * jresult ;
35689   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35690   Dali::Vector2 *result = 0 ;
35691
35692   arg1 = (Dali::PanGesture *)jarg1;
35693   result = (Dali::Vector2 *)& ((arg1)->displacement);
35694   jresult = (void *)result;
35695   return jresult;
35696 }
35697
35698
35699 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_position_set(void * jarg1, void * jarg2) {
35700   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35701   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35702
35703   arg1 = (Dali::PanGesture *)jarg1;
35704   arg2 = (Dali::Vector2 *)jarg2;
35705   if (arg1) (arg1)->position = *arg2;
35706 }
35707
35708
35709 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_position_get(void * jarg1) {
35710   void * jresult ;
35711   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35712   Dali::Vector2 *result = 0 ;
35713
35714   arg1 = (Dali::PanGesture *)jarg1;
35715   result = (Dali::Vector2 *)& ((arg1)->position);
35716   jresult = (void *)result;
35717   return jresult;
35718 }
35719
35720
35721 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
35722   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35723   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35724
35725   arg1 = (Dali::PanGesture *)jarg1;
35726   arg2 = (Dali::Vector2 *)jarg2;
35727   if (arg1) (arg1)->screenVelocity = *arg2;
35728 }
35729
35730
35731 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenVelocity_get(void * jarg1) {
35732   void * jresult ;
35733   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35734   Dali::Vector2 *result = 0 ;
35735
35736   arg1 = (Dali::PanGesture *)jarg1;
35737   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
35738   jresult = (void *)result;
35739   return jresult;
35740 }
35741
35742
35743 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
35744   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35745   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35746
35747   arg1 = (Dali::PanGesture *)jarg1;
35748   arg2 = (Dali::Vector2 *)jarg2;
35749   if (arg1) (arg1)->screenDisplacement = *arg2;
35750 }
35751
35752
35753 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenDisplacement_get(void * jarg1) {
35754   void * jresult ;
35755   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35756   Dali::Vector2 *result = 0 ;
35757
35758   arg1 = (Dali::PanGesture *)jarg1;
35759   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
35760   jresult = (void *)result;
35761   return jresult;
35762 }
35763
35764
35765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
35766   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35767   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35768
35769   arg1 = (Dali::PanGesture *)jarg1;
35770   arg2 = (Dali::Vector2 *)jarg2;
35771   if (arg1) (arg1)->screenPosition = *arg2;
35772 }
35773
35774
35775 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenPosition_get(void * jarg1) {
35776   void * jresult ;
35777   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35778   Dali::Vector2 *result = 0 ;
35779
35780   arg1 = (Dali::PanGesture *)jarg1;
35781   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
35782   jresult = (void *)result;
35783   return jresult;
35784 }
35785
35786
35787 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
35788   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35789   unsigned int arg2 ;
35790
35791   arg1 = (Dali::PanGesture *)jarg1;
35792   arg2 = (unsigned int)jarg2;
35793   if (arg1) (arg1)->numberOfTouches = arg2;
35794 }
35795
35796
35797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGesture_numberOfTouches_get(void * jarg1) {
35798   unsigned int jresult ;
35799   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35800   unsigned int result;
35801
35802   arg1 = (Dali::PanGesture *)jarg1;
35803   result = (unsigned int) ((arg1)->numberOfTouches);
35804   jresult = result;
35805   return jresult;
35806 }
35807
35808
35809 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetSpeed(void * jarg1) {
35810   float jresult ;
35811   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35812   float result;
35813
35814   arg1 = (Dali::PanGesture *)jarg1;
35815   {
35816     try {
35817       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
35818     } catch (std::out_of_range& e) {
35819       {
35820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35821       };
35822     } catch (std::exception& e) {
35823       {
35824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35825       };
35826     } catch (...) {
35827       {
35828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35829       };
35830     }
35831   }
35832   jresult = result;
35833   return jresult;
35834 }
35835
35836
35837 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetDistance(void * jarg1) {
35838   float jresult ;
35839   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35840   float result;
35841
35842   arg1 = (Dali::PanGesture *)jarg1;
35843   {
35844     try {
35845       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
35846     } catch (std::out_of_range& e) {
35847       {
35848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35849       };
35850     } catch (std::exception& e) {
35851       {
35852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35853       };
35854     } catch (...) {
35855       {
35856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35857       };
35858     }
35859   }
35860   jresult = result;
35861   return jresult;
35862 }
35863
35864
35865 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetScreenSpeed(void * jarg1) {
35866   float jresult ;
35867   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35868   float result;
35869
35870   arg1 = (Dali::PanGesture *)jarg1;
35871   {
35872     try {
35873       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
35874     } catch (std::out_of_range& e) {
35875       {
35876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35877       };
35878     } catch (std::exception& e) {
35879       {
35880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35881       };
35882     } catch (...) {
35883       {
35884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35885       };
35886     }
35887   }
35888   jresult = result;
35889   return jresult;
35890 }
35891
35892
35893 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetScreenDistance(void * jarg1) {
35894   float jresult ;
35895   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35896   float result;
35897
35898   arg1 = (Dali::PanGesture *)jarg1;
35899   {
35900     try {
35901       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
35902     } catch (std::out_of_range& e) {
35903       {
35904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35905       };
35906     } catch (std::exception& e) {
35907       {
35908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35909       };
35910     } catch (...) {
35911       {
35912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35913       };
35914     }
35915   }
35916   jresult = result;
35917   return jresult;
35918 }
35919
35920
35921 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetector__SWIG_0() {
35922   void * jresult ;
35923   Dali::PinchGestureDetector *result = 0 ;
35924
35925   {
35926     try {
35927       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
35928     } catch (std::out_of_range& e) {
35929       {
35930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (std::exception& e) {
35933       {
35934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (...) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35939       };
35940     }
35941   }
35942   jresult = (void *)result;
35943   return jresult;
35944 }
35945
35946
35947 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_New() {
35948   void * jresult ;
35949   Dali::PinchGestureDetector result;
35950
35951   {
35952     try {
35953       result = Dali::PinchGestureDetector::New();
35954     } catch (std::out_of_range& e) {
35955       {
35956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (std::exception& e) {
35959       {
35960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35961       };
35962     } catch (...) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35965       };
35966     }
35967   }
35968   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35969   return jresult;
35970 }
35971
35972
35973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_DownCast(void * jarg1) {
35974   void * jresult ;
35975   Dali::BaseHandle arg1 ;
35976   Dali::BaseHandle *argp1 ;
35977   Dali::PinchGestureDetector result;
35978
35979   argp1 = (Dali::BaseHandle *)jarg1;
35980   if (!argp1) {
35981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35982     return 0;
35983   }
35984   arg1 = *argp1;
35985   {
35986     try {
35987       result = Dali::PinchGestureDetector::DownCast(arg1);
35988     } catch (std::out_of_range& e) {
35989       {
35990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35991       };
35992     } catch (std::exception& e) {
35993       {
35994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35995       };
35996     } catch (...) {
35997       {
35998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35999       };
36000     }
36001   }
36002   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36003   return jresult;
36004 }
36005
36006
36007 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGestureDetector(void * jarg1) {
36008   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36009
36010   arg1 = (Dali::PinchGestureDetector *)jarg1;
36011   {
36012     try {
36013       delete arg1;
36014     } catch (std::out_of_range& e) {
36015       {
36016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36017       };
36018     } catch (std::exception& e) {
36019       {
36020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36021       };
36022     } catch (...) {
36023       {
36024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36025       };
36026     }
36027   }
36028 }
36029
36030
36031 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36032   void * jresult ;
36033   Dali::PinchGestureDetector *arg1 = 0 ;
36034   Dali::PinchGestureDetector *result = 0 ;
36035
36036   arg1 = (Dali::PinchGestureDetector *)jarg1;
36037   if (!arg1) {
36038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36039     return 0;
36040   }
36041   {
36042     try {
36043       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36044     } catch (std::out_of_range& e) {
36045       {
36046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36047       };
36048     } catch (std::exception& e) {
36049       {
36050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36051       };
36052     } catch (...) {
36053       {
36054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36055       };
36056     }
36057   }
36058   jresult = (void *)result;
36059   return jresult;
36060 }
36061
36062
36063 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36064   void * jresult ;
36065   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36066   Dali::PinchGestureDetector *arg2 = 0 ;
36067   Dali::PinchGestureDetector *result = 0 ;
36068
36069   arg1 = (Dali::PinchGestureDetector *)jarg1;
36070   arg2 = (Dali::PinchGestureDetector *)jarg2;
36071   if (!arg2) {
36072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36073     return 0;
36074   }
36075   {
36076     try {
36077       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36078     } catch (std::out_of_range& e) {
36079       {
36080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36081       };
36082     } catch (std::exception& e) {
36083       {
36084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36085       };
36086     } catch (...) {
36087       {
36088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36089       };
36090     }
36091   }
36092   jresult = (void *)result;
36093   return jresult;
36094 }
36095
36096
36097 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_DetectedSignal(void * jarg1) {
36098   void * jresult ;
36099   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36100   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36101
36102   arg1 = (Dali::PinchGestureDetector *)jarg1;
36103   {
36104     try {
36105       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36106     } catch (std::out_of_range& e) {
36107       {
36108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36109       };
36110     } catch (std::exception& e) {
36111       {
36112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36113       };
36114     } catch (...) {
36115       {
36116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36117       };
36118     }
36119   }
36120   jresult = (void *)result;
36121   return jresult;
36122 }
36123
36124
36125 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGesture__SWIG_0(int jarg1) {
36126   void * jresult ;
36127   Dali::Gesture::State arg1 ;
36128   Dali::PinchGesture *result = 0 ;
36129
36130   arg1 = (Dali::Gesture::State)jarg1;
36131   {
36132     try {
36133       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36134     } catch (std::out_of_range& e) {
36135       {
36136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36137       };
36138     } catch (std::exception& e) {
36139       {
36140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36141       };
36142     } catch (...) {
36143       {
36144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36145       };
36146     }
36147   }
36148   jresult = (void *)result;
36149   return jresult;
36150 }
36151
36152
36153 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGesture__SWIG_1(void * jarg1) {
36154   void * jresult ;
36155   Dali::PinchGesture *arg1 = 0 ;
36156   Dali::PinchGesture *result = 0 ;
36157
36158   arg1 = (Dali::PinchGesture *)jarg1;
36159   if (!arg1) {
36160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36161     return 0;
36162   }
36163   {
36164     try {
36165       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36166     } catch (std::out_of_range& e) {
36167       {
36168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36169       };
36170     } catch (std::exception& e) {
36171       {
36172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36173       };
36174     } catch (...) {
36175       {
36176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36177       };
36178     }
36179   }
36180   jresult = (void *)result;
36181   return jresult;
36182 }
36183
36184
36185 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_Assign(void * jarg1, void * jarg2) {
36186   void * jresult ;
36187   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36188   Dali::PinchGesture *arg2 = 0 ;
36189   Dali::PinchGesture *result = 0 ;
36190
36191   arg1 = (Dali::PinchGesture *)jarg1;
36192   arg2 = (Dali::PinchGesture *)jarg2;
36193   if (!arg2) {
36194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36195     return 0;
36196   }
36197   {
36198     try {
36199       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36200     } catch (std::out_of_range& e) {
36201       {
36202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36203       };
36204     } catch (std::exception& e) {
36205       {
36206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36207       };
36208     } catch (...) {
36209       {
36210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36211       };
36212     }
36213   }
36214   jresult = (void *)result;
36215   return jresult;
36216 }
36217
36218
36219 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGesture(void * jarg1) {
36220   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36221
36222   arg1 = (Dali::PinchGesture *)jarg1;
36223   {
36224     try {
36225       delete arg1;
36226     } catch (std::out_of_range& e) {
36227       {
36228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36229       };
36230     } catch (std::exception& e) {
36231       {
36232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36233       };
36234     } catch (...) {
36235       {
36236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36237       };
36238     }
36239   }
36240 }
36241
36242
36243 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_scale_set(void * jarg1, float jarg2) {
36244   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36245   float arg2 ;
36246
36247   arg1 = (Dali::PinchGesture *)jarg1;
36248   arg2 = (float)jarg2;
36249   if (arg1) (arg1)->scale = arg2;
36250 }
36251
36252
36253 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PinchGesture_scale_get(void * jarg1) {
36254   float jresult ;
36255   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36256   float result;
36257
36258   arg1 = (Dali::PinchGesture *)jarg1;
36259   result = (float) ((arg1)->scale);
36260   jresult = result;
36261   return jresult;
36262 }
36263
36264
36265 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_speed_set(void * jarg1, float jarg2) {
36266   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36267   float arg2 ;
36268
36269   arg1 = (Dali::PinchGesture *)jarg1;
36270   arg2 = (float)jarg2;
36271   if (arg1) (arg1)->speed = arg2;
36272 }
36273
36274
36275 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PinchGesture_speed_get(void * jarg1) {
36276   float jresult ;
36277   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36278   float result;
36279
36280   arg1 = (Dali::PinchGesture *)jarg1;
36281   result = (float) ((arg1)->speed);
36282   jresult = result;
36283   return jresult;
36284 }
36285
36286
36287 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36288   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36289   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36290
36291   arg1 = (Dali::PinchGesture *)jarg1;
36292   arg2 = (Dali::Vector2 *)jarg2;
36293   if (arg1) (arg1)->screenCenterPoint = *arg2;
36294 }
36295
36296
36297 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_screenCenterPoint_get(void * jarg1) {
36298   void * jresult ;
36299   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36300   Dali::Vector2 *result = 0 ;
36301
36302   arg1 = (Dali::PinchGesture *)jarg1;
36303   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36304   jresult = (void *)result;
36305   return jresult;
36306 }
36307
36308
36309 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36310   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36311   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36312
36313   arg1 = (Dali::PinchGesture *)jarg1;
36314   arg2 = (Dali::Vector2 *)jarg2;
36315   if (arg1) (arg1)->localCenterPoint = *arg2;
36316 }
36317
36318
36319 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_localCenterPoint_get(void * jarg1) {
36320   void * jresult ;
36321   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36322   Dali::Vector2 *result = 0 ;
36323
36324   arg1 = (Dali::PinchGesture *)jarg1;
36325   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36326   jresult = (void *)result;
36327   return jresult;
36328 }
36329
36330
36331 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetector__SWIG_0() {
36332   void * jresult ;
36333   Dali::TapGestureDetector *result = 0 ;
36334
36335   {
36336     try {
36337       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36338     } catch (std::out_of_range& e) {
36339       {
36340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36341       };
36342     } catch (std::exception& e) {
36343       {
36344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36345       };
36346     } catch (...) {
36347       {
36348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36349       };
36350     }
36351   }
36352   jresult = (void *)result;
36353   return jresult;
36354 }
36355
36356
36357 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_New__SWIG_0() {
36358   void * jresult ;
36359   Dali::TapGestureDetector result;
36360
36361   {
36362     try {
36363       result = Dali::TapGestureDetector::New();
36364     } catch (std::out_of_range& e) {
36365       {
36366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36367       };
36368     } catch (std::exception& e) {
36369       {
36370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36371       };
36372     } catch (...) {
36373       {
36374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36375       };
36376     }
36377   }
36378   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36379   return jresult;
36380 }
36381
36382
36383 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36384   void * jresult ;
36385   unsigned int arg1 ;
36386   Dali::TapGestureDetector result;
36387
36388   arg1 = (unsigned int)jarg1;
36389   {
36390     try {
36391       result = Dali::TapGestureDetector::New(arg1);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_DownCast(void * jarg1) {
36412   void * jresult ;
36413   Dali::BaseHandle arg1 ;
36414   Dali::BaseHandle *argp1 ;
36415   Dali::TapGestureDetector result;
36416
36417   argp1 = (Dali::BaseHandle *)jarg1;
36418   if (!argp1) {
36419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36420     return 0;
36421   }
36422   arg1 = *argp1;
36423   {
36424     try {
36425       result = Dali::TapGestureDetector::DownCast(arg1);
36426     } catch (std::out_of_range& e) {
36427       {
36428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36429       };
36430     } catch (std::exception& e) {
36431       {
36432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36433       };
36434     } catch (...) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36437       };
36438     }
36439   }
36440   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGestureDetector(void * jarg1) {
36446   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36447
36448   arg1 = (Dali::TapGestureDetector *)jarg1;
36449   {
36450     try {
36451       delete arg1;
36452     } catch (std::out_of_range& e) {
36453       {
36454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36455       };
36456     } catch (std::exception& e) {
36457       {
36458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36459       };
36460     } catch (...) {
36461       {
36462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36463       };
36464     }
36465   }
36466 }
36467
36468
36469 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetector__SWIG_1(void * jarg1) {
36470   void * jresult ;
36471   Dali::TapGestureDetector *arg1 = 0 ;
36472   Dali::TapGestureDetector *result = 0 ;
36473
36474   arg1 = (Dali::TapGestureDetector *)jarg1;
36475   if (!arg1) {
36476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36477     return 0;
36478   }
36479   {
36480     try {
36481       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36482     } catch (std::out_of_range& e) {
36483       {
36484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (std::exception& e) {
36487       {
36488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (...) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36493       };
36494     }
36495   }
36496   jresult = (void *)result;
36497   return jresult;
36498 }
36499
36500
36501 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36502   void * jresult ;
36503   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36504   Dali::TapGestureDetector *arg2 = 0 ;
36505   Dali::TapGestureDetector *result = 0 ;
36506
36507   arg1 = (Dali::TapGestureDetector *)jarg1;
36508   arg2 = (Dali::TapGestureDetector *)jarg2;
36509   if (!arg2) {
36510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36511     return 0;
36512   }
36513   {
36514     try {
36515       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36516     } catch (std::out_of_range& e) {
36517       {
36518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36519       };
36520     } catch (std::exception& e) {
36521       {
36522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (...) {
36525       {
36526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36527       };
36528     }
36529   }
36530   jresult = (void *)result;
36531   return jresult;
36532 }
36533
36534
36535 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36536   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36537   unsigned int arg2 ;
36538
36539   arg1 = (Dali::TapGestureDetector *)jarg1;
36540   arg2 = (unsigned int)jarg2;
36541   {
36542     try {
36543       (arg1)->SetMinimumTapsRequired(arg2);
36544     } catch (std::out_of_range& e) {
36545       {
36546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36547       };
36548     } catch (std::exception& e) {
36549       {
36550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36551       };
36552     } catch (...) {
36553       {
36554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36555       };
36556     }
36557   }
36558 }
36559
36560
36561 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36562   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36563   unsigned int arg2 ;
36564
36565   arg1 = (Dali::TapGestureDetector *)jarg1;
36566   arg2 = (unsigned int)jarg2;
36567   {
36568     try {
36569       (arg1)->SetMaximumTapsRequired(arg2);
36570     } catch (std::out_of_range& e) {
36571       {
36572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36573       };
36574     } catch (std::exception& e) {
36575       {
36576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36577       };
36578     } catch (...) {
36579       {
36580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36581       };
36582     }
36583   }
36584 }
36585
36586
36587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36588   unsigned int jresult ;
36589   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36590   unsigned int result;
36591
36592   arg1 = (Dali::TapGestureDetector *)jarg1;
36593   {
36594     try {
36595       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36596     } catch (std::out_of_range& e) {
36597       {
36598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36599       };
36600     } catch (std::exception& e) {
36601       {
36602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36607       };
36608     }
36609   }
36610   jresult = result;
36611   return jresult;
36612 }
36613
36614
36615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36616   unsigned int jresult ;
36617   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36618   unsigned int result;
36619
36620   arg1 = (Dali::TapGestureDetector *)jarg1;
36621   {
36622     try {
36623       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36624     } catch (std::out_of_range& e) {
36625       {
36626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36627       };
36628     } catch (std::exception& e) {
36629       {
36630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (...) {
36633       {
36634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36635       };
36636     }
36637   }
36638   jresult = result;
36639   return jresult;
36640 }
36641
36642
36643 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_DetectedSignal(void * jarg1) {
36644   void * jresult ;
36645   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36646   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36647
36648   arg1 = (Dali::TapGestureDetector *)jarg1;
36649   {
36650     try {
36651       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36652     } catch (std::out_of_range& e) {
36653       {
36654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36655       };
36656     } catch (std::exception& e) {
36657       {
36658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36659       };
36660     } catch (...) {
36661       {
36662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36663       };
36664     }
36665   }
36666   jresult = (void *)result;
36667   return jresult;
36668 }
36669
36670
36671 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGesture__SWIG_0() {
36672   void * jresult ;
36673   Dali::TapGesture *result = 0 ;
36674
36675   {
36676     try {
36677       result = (Dali::TapGesture *)new Dali::TapGesture();
36678     } catch (std::out_of_range& e) {
36679       {
36680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36681       };
36682     } catch (std::exception& e) {
36683       {
36684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36685       };
36686     } catch (...) {
36687       {
36688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36689       };
36690     }
36691   }
36692   jresult = (void *)result;
36693   return jresult;
36694 }
36695
36696
36697 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGesture__SWIG_1(void * jarg1) {
36698   void * jresult ;
36699   Dali::TapGesture *arg1 = 0 ;
36700   Dali::TapGesture *result = 0 ;
36701
36702   arg1 = (Dali::TapGesture *)jarg1;
36703   if (!arg1) {
36704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36705     return 0;
36706   }
36707   {
36708     try {
36709       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
36710     } catch (std::out_of_range& e) {
36711       {
36712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36713       };
36714     } catch (std::exception& e) {
36715       {
36716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36717       };
36718     } catch (...) {
36719       {
36720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36721       };
36722     }
36723   }
36724   jresult = (void *)result;
36725   return jresult;
36726 }
36727
36728
36729 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_Assign(void * jarg1, void * jarg2) {
36730   void * jresult ;
36731   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36732   Dali::TapGesture *arg2 = 0 ;
36733   Dali::TapGesture *result = 0 ;
36734
36735   arg1 = (Dali::TapGesture *)jarg1;
36736   arg2 = (Dali::TapGesture *)jarg2;
36737   if (!arg2) {
36738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36739     return 0;
36740   }
36741   {
36742     try {
36743       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
36744     } catch (std::out_of_range& e) {
36745       {
36746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36747       };
36748     } catch (std::exception& e) {
36749       {
36750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36751       };
36752     } catch (...) {
36753       {
36754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36755       };
36756     }
36757   }
36758   jresult = (void *)result;
36759   return jresult;
36760 }
36761
36762
36763 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGesture(void * jarg1) {
36764   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36765
36766   arg1 = (Dali::TapGesture *)jarg1;
36767   {
36768     try {
36769       delete arg1;
36770     } catch (std::out_of_range& e) {
36771       {
36772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36773       };
36774     } catch (std::exception& e) {
36775       {
36776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36777       };
36778     } catch (...) {
36779       {
36780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36781       };
36782     }
36783   }
36784 }
36785
36786
36787 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
36788   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36789   unsigned int arg2 ;
36790
36791   arg1 = (Dali::TapGesture *)jarg1;
36792   arg2 = (unsigned int)jarg2;
36793   if (arg1) (arg1)->numberOfTaps = arg2;
36794 }
36795
36796
36797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTaps_get(void * jarg1) {
36798   unsigned int jresult ;
36799   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36800   unsigned int result;
36801
36802   arg1 = (Dali::TapGesture *)jarg1;
36803   result = (unsigned int) ((arg1)->numberOfTaps);
36804   jresult = result;
36805   return jresult;
36806 }
36807
36808
36809 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36810   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36811   unsigned int arg2 ;
36812
36813   arg1 = (Dali::TapGesture *)jarg1;
36814   arg2 = (unsigned int)jarg2;
36815   if (arg1) (arg1)->numberOfTouches = arg2;
36816 }
36817
36818
36819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTouches_get(void * jarg1) {
36820   unsigned int jresult ;
36821   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36822   unsigned int result;
36823
36824   arg1 = (Dali::TapGesture *)jarg1;
36825   result = (unsigned int) ((arg1)->numberOfTouches);
36826   jresult = result;
36827   return jresult;
36828 }
36829
36830
36831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
36832   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36833   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36834
36835   arg1 = (Dali::TapGesture *)jarg1;
36836   arg2 = (Dali::Vector2 *)jarg2;
36837   if (arg1) (arg1)->screenPoint = *arg2;
36838 }
36839
36840
36841 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_screenPoint_get(void * jarg1) {
36842   void * jresult ;
36843   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36844   Dali::Vector2 *result = 0 ;
36845
36846   arg1 = (Dali::TapGesture *)jarg1;
36847   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
36848   jresult = (void *)result;
36849   return jresult;
36850 }
36851
36852
36853 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
36854   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36855   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36856
36857   arg1 = (Dali::TapGesture *)jarg1;
36858   arg2 = (Dali::Vector2 *)jarg2;
36859   if (arg1) (arg1)->localPoint = *arg2;
36860 }
36861
36862
36863 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_localPoint_get(void * jarg1) {
36864   void * jresult ;
36865   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36866   Dali::Vector2 *result = 0 ;
36867
36868   arg1 = (Dali::TapGesture *)jarg1;
36869   result = (Dali::Vector2 *)& ((arg1)->localPoint);
36870   jresult = (void *)result;
36871   return jresult;
36872 }
36873
36874
36875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchEvent__SWIG_0() {
36876   void * jresult ;
36877   Dali::TouchEvent *result = 0 ;
36878
36879   {
36880     try {
36881       result = (Dali::TouchEvent *)new Dali::TouchEvent();
36882     } catch (std::out_of_range& e) {
36883       {
36884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36885       };
36886     } catch (std::exception& e) {
36887       {
36888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36889       };
36890     } catch (...) {
36891       {
36892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36893       };
36894     }
36895   }
36896   jresult = (void *)result;
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchEvent__SWIG_1(unsigned long jarg1) {
36902   void * jresult ;
36903   unsigned long arg1 ;
36904   Dali::TouchEvent *result = 0 ;
36905
36906   arg1 = (unsigned long)jarg1;
36907   {
36908     try {
36909       result = (Dali::TouchEvent *)new Dali::TouchEvent(arg1);
36910     } catch (std::out_of_range& e) {
36911       {
36912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36913       };
36914     } catch (std::exception& e) {
36915       {
36916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36917       };
36918     } catch (...) {
36919       {
36920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36921       };
36922     }
36923   }
36924   jresult = (void *)result;
36925   return jresult;
36926 }
36927
36928
36929 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchEvent(void * jarg1) {
36930   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36931
36932   arg1 = (Dali::TouchEvent *)jarg1;
36933   {
36934     try {
36935       delete arg1;
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36943       };
36944     } catch (...) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36947       };
36948     }
36949   }
36950 }
36951
36952
36953 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchEvent_points_set(void * jarg1, void * jarg2) {
36954   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36955   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
36956
36957   arg1 = (Dali::TouchEvent *)jarg1;
36958   arg2 = (Dali::TouchPointContainer *)jarg2;
36959   if (arg1) (arg1)->points = *arg2;
36960 }
36961
36962
36963 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchEvent_points_get(void * jarg1) {
36964   void * jresult ;
36965   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36966   Dali::TouchPointContainer *result = 0 ;
36967
36968   arg1 = (Dali::TouchEvent *)jarg1;
36969   result = (Dali::TouchPointContainer *)& ((arg1)->points);
36970   jresult = (void *)result;
36971   return jresult;
36972 }
36973
36974
36975 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchEvent_time_set(void * jarg1, unsigned long jarg2) {
36976   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36977   unsigned long arg2 ;
36978
36979   arg1 = (Dali::TouchEvent *)jarg1;
36980   arg2 = (unsigned long)jarg2;
36981   if (arg1) (arg1)->time = arg2;
36982 }
36983
36984
36985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchEvent_time_get(void * jarg1) {
36986   unsigned long jresult ;
36987   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36988   unsigned long result;
36989
36990   arg1 = (Dali::TouchEvent *)jarg1;
36991   result = (unsigned long) ((arg1)->time);
36992   jresult = (unsigned long)result;
36993   return jresult;
36994 }
36995
36996
36997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TouchEvent_GetPointCount(void * jarg1) {
36998   unsigned int jresult ;
36999   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
37000   unsigned int result;
37001
37002   arg1 = (Dali::TouchEvent *)jarg1;
37003   {
37004     try {
37005       result = (unsigned int)((Dali::TouchEvent const *)arg1)->GetPointCount();
37006     } catch (std::out_of_range& e) {
37007       {
37008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (std::exception& e) {
37011       {
37012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37017       };
37018     }
37019   }
37020   jresult = result;
37021   return jresult;
37022 }
37023
37024
37025 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchEvent_GetPoint(void * jarg1, unsigned int jarg2) {
37026   void * jresult ;
37027   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
37028   unsigned int arg2 ;
37029   Dali::TouchPoint *result = 0 ;
37030
37031   arg1 = (Dali::TouchEvent *)jarg1;
37032   arg2 = (unsigned int)jarg2;
37033   {
37034     try {
37035       result = (Dali::TouchPoint *) &((Dali::TouchEvent const *)arg1)->GetPoint(arg2);
37036     } catch (std::out_of_range& e) {
37037       {
37038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37039       };
37040     } catch (std::exception& e) {
37041       {
37042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37043       };
37044     } catch (...) {
37045       {
37046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37047       };
37048     }
37049   }
37050   jresult = (void *)result;
37051   return jresult;
37052 }
37053
37054
37055 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_0() {
37056   void * jresult ;
37057   Dali::AlphaFunction *result = 0 ;
37058
37059   {
37060     try {
37061       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37062     } catch (std::out_of_range& e) {
37063       {
37064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37065       };
37066     } catch (std::exception& e) {
37067       {
37068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (...) {
37071       {
37072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37073       };
37074     }
37075   }
37076   jresult = (void *)result;
37077   return jresult;
37078 }
37079
37080
37081 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_1(int jarg1) {
37082   void * jresult ;
37083   Dali::AlphaFunction::BuiltinFunction arg1 ;
37084   Dali::AlphaFunction *result = 0 ;
37085
37086   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37087   {
37088     try {
37089       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37090     } catch (std::out_of_range& e) {
37091       {
37092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37093       };
37094     } catch (std::exception& e) {
37095       {
37096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37097       };
37098     } catch (...) {
37099       {
37100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37101       };
37102     }
37103   }
37104   jresult = (void *)result;
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_2(void * jarg1) {
37110   void * jresult ;
37111   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37112   Dali::AlphaFunction *result = 0 ;
37113
37114   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37115   {
37116     try {
37117       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37118     } catch (std::out_of_range& e) {
37119       {
37120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37121       };
37122     } catch (std::exception& e) {
37123       {
37124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37125       };
37126     } catch (...) {
37127       {
37128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37129       };
37130     }
37131   }
37132   jresult = (void *)result;
37133   return jresult;
37134 }
37135
37136
37137 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37138   void * jresult ;
37139   Dali::Vector2 *arg1 = 0 ;
37140   Dali::Vector2 *arg2 = 0 ;
37141   Dali::AlphaFunction *result = 0 ;
37142
37143   arg1 = (Dali::Vector2 *)jarg1;
37144   if (!arg1) {
37145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37146     return 0;
37147   }
37148   arg2 = (Dali::Vector2 *)jarg2;
37149   if (!arg2) {
37150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37151     return 0;
37152   }
37153   {
37154     try {
37155       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37156     } catch (std::out_of_range& e) {
37157       {
37158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37159       };
37160     } catch (std::exception& e) {
37161       {
37162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37163       };
37164     } catch (...) {
37165       {
37166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37167       };
37168     }
37169   }
37170   jresult = (void *)result;
37171   return jresult;
37172 }
37173
37174
37175 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37176   void * jresult ;
37177   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37178   Dali::Vector4 result;
37179
37180   arg1 = (Dali::AlphaFunction *)jarg1;
37181   {
37182     try {
37183       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37184     } catch (std::out_of_range& e) {
37185       {
37186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37187       };
37188     } catch (std::exception& e) {
37189       {
37190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37191       };
37192     } catch (...) {
37193       {
37194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37195       };
37196     }
37197   }
37198   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37199   return jresult;
37200 }
37201
37202
37203 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AlphaFunction_GetCustomFunction(void * jarg1) {
37204   void * jresult ;
37205   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37206   Dali::AlphaFunctionPrototype result;
37207
37208   arg1 = (Dali::AlphaFunction *)jarg1;
37209   {
37210     try {
37211       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37212     } catch (std::out_of_range& e) {
37213       {
37214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37215       };
37216     } catch (std::exception& e) {
37217       {
37218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37219       };
37220     } catch (...) {
37221       {
37222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37223       };
37224     }
37225   }
37226   jresult = (void *)result;
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37232   int jresult ;
37233   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37234   Dali::AlphaFunction::BuiltinFunction result;
37235
37236   arg1 = (Dali::AlphaFunction *)jarg1;
37237   {
37238     try {
37239       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37240     } catch (std::out_of_range& e) {
37241       {
37242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37243       };
37244     } catch (std::exception& e) {
37245       {
37246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37247       };
37248     } catch (...) {
37249       {
37250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37251       };
37252     }
37253   }
37254   jresult = (int)result;
37255   return jresult;
37256 }
37257
37258
37259 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_AlphaFunction_GetMode(void * jarg1) {
37260   int jresult ;
37261   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37262   Dali::AlphaFunction::Mode result;
37263
37264   arg1 = (Dali::AlphaFunction *)jarg1;
37265   {
37266     try {
37267       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37268     } catch (std::out_of_range& e) {
37269       {
37270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37271       };
37272     } catch (std::exception& e) {
37273       {
37274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37275       };
37276     } catch (...) {
37277       {
37278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37279       };
37280     }
37281   }
37282   jresult = (int)result;
37283   return jresult;
37284 }
37285
37286
37287 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AlphaFunction(void * jarg1) {
37288   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37289
37290   arg1 = (Dali::AlphaFunction *)jarg1;
37291   {
37292     try {
37293       delete arg1;
37294     } catch (std::out_of_range& e) {
37295       {
37296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37297       };
37298     } catch (std::exception& e) {
37299       {
37300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37305       };
37306     }
37307   }
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_New() {
37312   void * jresult ;
37313   Dali::KeyFrames result;
37314
37315   {
37316     try {
37317       result = Dali::KeyFrames::New();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (...) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37329       };
37330     }
37331   }
37332   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37333   return jresult;
37334 }
37335
37336
37337 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_DownCast(void * jarg1) {
37338   void * jresult ;
37339   Dali::BaseHandle arg1 ;
37340   Dali::BaseHandle *argp1 ;
37341   Dali::KeyFrames result;
37342
37343   argp1 = (Dali::BaseHandle *)jarg1;
37344   if (!argp1) {
37345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37346     return 0;
37347   }
37348   arg1 = *argp1;
37349   {
37350     try {
37351       result = Dali::KeyFrames::DownCast(arg1);
37352     } catch (std::out_of_range& e) {
37353       {
37354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37355       };
37356     } catch (std::exception& e) {
37357       {
37358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37359       };
37360     } catch (...) {
37361       {
37362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37363       };
37364     }
37365   }
37366   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37367   return jresult;
37368 }
37369
37370
37371 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyFrames__SWIG_0() {
37372   void * jresult ;
37373   Dali::KeyFrames *result = 0 ;
37374
37375   {
37376     try {
37377       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37378     } catch (std::out_of_range& e) {
37379       {
37380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37381       };
37382     } catch (std::exception& e) {
37383       {
37384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37385       };
37386     } catch (...) {
37387       {
37388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37389       };
37390     }
37391   }
37392   jresult = (void *)result;
37393   return jresult;
37394 }
37395
37396
37397 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyFrames(void * jarg1) {
37398   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37399
37400   arg1 = (Dali::KeyFrames *)jarg1;
37401   {
37402     try {
37403       delete arg1;
37404     } catch (std::out_of_range& e) {
37405       {
37406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37407       };
37408     } catch (std::exception& e) {
37409       {
37410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37411       };
37412     } catch (...) {
37413       {
37414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37415       };
37416     }
37417   }
37418 }
37419
37420
37421 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyFrames__SWIG_1(void * jarg1) {
37422   void * jresult ;
37423   Dali::KeyFrames *arg1 = 0 ;
37424   Dali::KeyFrames *result = 0 ;
37425
37426   arg1 = (Dali::KeyFrames *)jarg1;
37427   if (!arg1) {
37428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37429     return 0;
37430   }
37431   {
37432     try {
37433       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37434     } catch (std::out_of_range& e) {
37435       {
37436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37437       };
37438     } catch (std::exception& e) {
37439       {
37440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37441       };
37442     } catch (...) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37445       };
37446     }
37447   }
37448   jresult = (void *)result;
37449   return jresult;
37450 }
37451
37452
37453 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_Assign(void * jarg1, void * jarg2) {
37454   void * jresult ;
37455   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37456   Dali::KeyFrames *arg2 = 0 ;
37457   Dali::KeyFrames *result = 0 ;
37458
37459   arg1 = (Dali::KeyFrames *)jarg1;
37460   arg2 = (Dali::KeyFrames *)jarg2;
37461   if (!arg2) {
37462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37463     return 0;
37464   }
37465   {
37466     try {
37467       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37468     } catch (std::out_of_range& e) {
37469       {
37470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37471       };
37472     } catch (std::exception& e) {
37473       {
37474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37475       };
37476     } catch (...) {
37477       {
37478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37479       };
37480     }
37481   }
37482   jresult = (void *)result;
37483   return jresult;
37484 }
37485
37486
37487 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyFrames_GetType(void * jarg1) {
37488   int jresult ;
37489   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37490   Dali::Property::Type result;
37491
37492   arg1 = (Dali::KeyFrames *)jarg1;
37493   {
37494     try {
37495       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37503       };
37504     } catch (...) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37507       };
37508     }
37509   }
37510   jresult = (int)result;
37511   return jresult;
37512 }
37513
37514
37515 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37516   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37517   float arg2 ;
37518   Dali::Property::Value arg3 ;
37519   Dali::Property::Value *argp3 ;
37520
37521   arg1 = (Dali::KeyFrames *)jarg1;
37522   arg2 = (float)jarg2;
37523   argp3 = (Dali::Property::Value *)jarg3;
37524   if (!argp3) {
37525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37526     return ;
37527   }
37528   arg3 = *argp3;
37529   {
37530     try {
37531       (arg1)->Add(arg2,arg3);
37532     } catch (std::out_of_range& e) {
37533       {
37534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37535       };
37536     } catch (std::exception& e) {
37537       {
37538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37539       };
37540     } catch (...) {
37541       {
37542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37543       };
37544     }
37545   }
37546 }
37547
37548
37549 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37550   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37551   float arg2 ;
37552   Dali::Property::Value arg3 ;
37553   Dali::AlphaFunction arg4 ;
37554   Dali::Property::Value *argp3 ;
37555   Dali::AlphaFunction *argp4 ;
37556
37557   arg1 = (Dali::KeyFrames *)jarg1;
37558   arg2 = (float)jarg2;
37559   argp3 = (Dali::Property::Value *)jarg3;
37560   if (!argp3) {
37561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37562     return ;
37563   }
37564   arg3 = *argp3;
37565   argp4 = (Dali::AlphaFunction *)jarg4;
37566   if (!argp4) {
37567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37568     return ;
37569   }
37570   arg4 = *argp4;
37571   {
37572     try {
37573       (arg1)->Add(arg2,arg3,arg4);
37574     } catch (std::out_of_range& e) {
37575       {
37576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (std::exception& e) {
37579       {
37580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37581       };
37582     } catch (...) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37585       };
37586     }
37587   }
37588 }
37589
37590
37591 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Path_Property_POINTS_get() {
37592   int jresult ;
37593   int result;
37594
37595   result = (int)Dali::Path::Property::POINTS;
37596   jresult = (int)result;
37597   return jresult;
37598 }
37599
37600
37601 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Path_Property_CONTROL_POINTS_get() {
37602   int jresult ;
37603   int result;
37604
37605   result = (int)Dali::Path::Property::CONTROL_POINTS;
37606   jresult = (int)result;
37607   return jresult;
37608 }
37609
37610
37611 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path_Property() {
37612   void * jresult ;
37613   Dali::Path::Property *result = 0 ;
37614
37615   {
37616     try {
37617       result = (Dali::Path::Property *)new Dali::Path::Property();
37618     } catch (std::out_of_range& e) {
37619       {
37620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37621       };
37622     } catch (std::exception& e) {
37623       {
37624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37625       };
37626     } catch (...) {
37627       {
37628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37629       };
37630     }
37631   }
37632   jresult = (void *)result;
37633   return jresult;
37634 }
37635
37636
37637 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Path_Property(void * jarg1) {
37638   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37639
37640   arg1 = (Dali::Path::Property *)jarg1;
37641   {
37642     try {
37643       delete arg1;
37644     } catch (std::out_of_range& e) {
37645       {
37646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37647       };
37648     } catch (std::exception& e) {
37649       {
37650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37655       };
37656     }
37657   }
37658 }
37659
37660
37661 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_New() {
37662   void * jresult ;
37663   Dali::Path result;
37664
37665   {
37666     try {
37667       result = Dali::Path::New();
37668     } catch (std::out_of_range& e) {
37669       {
37670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37671       };
37672     } catch (std::exception& e) {
37673       {
37674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37675       };
37676     } catch (...) {
37677       {
37678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37679       };
37680     }
37681   }
37682   jresult = new Dali::Path((const Dali::Path &)result);
37683   return jresult;
37684 }
37685
37686
37687 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_DownCast(void * jarg1) {
37688   void * jresult ;
37689   Dali::BaseHandle arg1 ;
37690   Dali::BaseHandle *argp1 ;
37691   Dali::Path result;
37692
37693   argp1 = (Dali::BaseHandle *)jarg1;
37694   if (!argp1) {
37695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37696     return 0;
37697   }
37698   arg1 = *argp1;
37699   {
37700     try {
37701       result = Dali::Path::DownCast(arg1);
37702     } catch (std::out_of_range& e) {
37703       {
37704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37705       };
37706     } catch (std::exception& e) {
37707       {
37708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37709       };
37710     } catch (...) {
37711       {
37712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37713       };
37714     }
37715   }
37716   jresult = new Dali::Path((const Dali::Path &)result);
37717   return jresult;
37718 }
37719
37720
37721 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path__SWIG_0() {
37722   void * jresult ;
37723   Dali::Path *result = 0 ;
37724
37725   {
37726     try {
37727       result = (Dali::Path *)new Dali::Path();
37728     } catch (std::out_of_range& e) {
37729       {
37730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37731       };
37732     } catch (std::exception& e) {
37733       {
37734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37735       };
37736     } catch (...) {
37737       {
37738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37739       };
37740     }
37741   }
37742   jresult = (void *)result;
37743   return jresult;
37744 }
37745
37746
37747 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Path(void * jarg1) {
37748   Dali::Path *arg1 = (Dali::Path *) 0 ;
37749
37750   arg1 = (Dali::Path *)jarg1;
37751   {
37752     try {
37753       delete arg1;
37754     } catch (std::out_of_range& e) {
37755       {
37756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37757       };
37758     } catch (std::exception& e) {
37759       {
37760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37761       };
37762     } catch (...) {
37763       {
37764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37765       };
37766     }
37767   }
37768 }
37769
37770
37771 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path__SWIG_1(void * jarg1) {
37772   void * jresult ;
37773   Dali::Path *arg1 = 0 ;
37774   Dali::Path *result = 0 ;
37775
37776   arg1 = (Dali::Path *)jarg1;
37777   if (!arg1) {
37778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37779     return 0;
37780   }
37781   {
37782     try {
37783       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37784     } catch (std::out_of_range& e) {
37785       {
37786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37787       };
37788     } catch (std::exception& e) {
37789       {
37790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37791       };
37792     } catch (...) {
37793       {
37794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37795       };
37796     }
37797   }
37798   jresult = (void *)result;
37799   return jresult;
37800 }
37801
37802
37803 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_Assign(void * jarg1, void * jarg2) {
37804   void * jresult ;
37805   Dali::Path *arg1 = (Dali::Path *) 0 ;
37806   Dali::Path *arg2 = 0 ;
37807   Dali::Path *result = 0 ;
37808
37809   arg1 = (Dali::Path *)jarg1;
37810   arg2 = (Dali::Path *)jarg2;
37811   if (!arg2) {
37812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37813     return 0;
37814   }
37815   {
37816     try {
37817       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37818     } catch (std::out_of_range& e) {
37819       {
37820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37821       };
37822     } catch (std::exception& e) {
37823       {
37824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37825       };
37826     } catch (...) {
37827       {
37828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37829       };
37830     }
37831   }
37832   jresult = (void *)result;
37833   return jresult;
37834 }
37835
37836
37837 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_AddPoint(void * jarg1, void * jarg2) {
37838   Dali::Path *arg1 = (Dali::Path *) 0 ;
37839   Dali::Vector3 *arg2 = 0 ;
37840
37841   arg1 = (Dali::Path *)jarg1;
37842   arg2 = (Dali::Vector3 *)jarg2;
37843   if (!arg2) {
37844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37845     return ;
37846   }
37847   {
37848     try {
37849       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
37850     } catch (std::out_of_range& e) {
37851       {
37852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (std::exception& e) {
37855       {
37856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37857       };
37858     } catch (...) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37861       };
37862     }
37863   }
37864 }
37865
37866
37867 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_AddControlPoint(void * jarg1, void * jarg2) {
37868   Dali::Path *arg1 = (Dali::Path *) 0 ;
37869   Dali::Vector3 *arg2 = 0 ;
37870
37871   arg1 = (Dali::Path *)jarg1;
37872   arg2 = (Dali::Vector3 *)jarg2;
37873   if (!arg2) {
37874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37875     return ;
37876   }
37877   {
37878     try {
37879       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
37880     } catch (std::out_of_range& e) {
37881       {
37882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37883       };
37884     } catch (std::exception& e) {
37885       {
37886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37887       };
37888     } catch (...) {
37889       {
37890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37891       };
37892     }
37893   }
37894 }
37895
37896
37897 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_GenerateControlPoints(void * jarg1, float jarg2) {
37898   Dali::Path *arg1 = (Dali::Path *) 0 ;
37899   float arg2 ;
37900
37901   arg1 = (Dali::Path *)jarg1;
37902   arg2 = (float)jarg2;
37903   {
37904     try {
37905       (arg1)->GenerateControlPoints(arg2);
37906     } catch (std::out_of_range& e) {
37907       {
37908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37909       };
37910     } catch (std::exception& e) {
37911       {
37912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37913       };
37914     } catch (...) {
37915       {
37916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37917       };
37918     }
37919   }
37920 }
37921
37922
37923 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37924   Dali::Path *arg1 = (Dali::Path *) 0 ;
37925   float arg2 ;
37926   Dali::Vector3 *arg3 = 0 ;
37927   Dali::Vector3 *arg4 = 0 ;
37928
37929   arg1 = (Dali::Path *)jarg1;
37930   arg2 = (float)jarg2;
37931   arg3 = (Dali::Vector3 *)jarg3;
37932   if (!arg3) {
37933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37934     return ;
37935   }
37936   arg4 = (Dali::Vector3 *)jarg4;
37937   if (!arg4) {
37938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37939     return ;
37940   }
37941   {
37942     try {
37943       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
37944     } catch (std::out_of_range& e) {
37945       {
37946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37947       };
37948     } catch (std::exception& e) {
37949       {
37950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37951       };
37952     } catch (...) {
37953       {
37954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37955       };
37956     }
37957   }
37958 }
37959
37960
37961 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_GetPoint(void * jarg1, unsigned long jarg2) {
37962   void * jresult ;
37963   Dali::Path *arg1 = (Dali::Path *) 0 ;
37964   size_t arg2 ;
37965   Dali::Vector3 *result = 0 ;
37966
37967   arg1 = (Dali::Path *)jarg1;
37968   arg2 = (size_t)jarg2;
37969   {
37970     try {
37971       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
37972     } catch (std::out_of_range& e) {
37973       {
37974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37975       };
37976     } catch (std::exception& e) {
37977       {
37978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (...) {
37981       {
37982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37983       };
37984     }
37985   }
37986   jresult = (void *)result;
37987   return jresult;
37988 }
37989
37990
37991 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
37992   void * jresult ;
37993   Dali::Path *arg1 = (Dali::Path *) 0 ;
37994   size_t arg2 ;
37995   Dali::Vector3 *result = 0 ;
37996
37997   arg1 = (Dali::Path *)jarg1;
37998   arg2 = (size_t)jarg2;
37999   {
38000     try {
38001       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38002     } catch (std::out_of_range& e) {
38003       {
38004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38005       };
38006     } catch (std::exception& e) {
38007       {
38008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38009       };
38010     } catch (...) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38013       };
38014     }
38015   }
38016   jresult = (void *)result;
38017   return jresult;
38018 }
38019
38020
38021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Path_GetPointCount(void * jarg1) {
38022   unsigned long jresult ;
38023   Dali::Path *arg1 = (Dali::Path *) 0 ;
38024   size_t result;
38025
38026   arg1 = (Dali::Path *)jarg1;
38027   {
38028     try {
38029       result = ((Dali::Path const *)arg1)->GetPointCount();
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38041       };
38042     }
38043   }
38044   jresult = (unsigned long)result;
38045   return jresult;
38046 }
38047
38048
38049 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimePeriod__SWIG_0(float jarg1) {
38050   void * jresult ;
38051   float arg1 ;
38052   Dali::TimePeriod *result = 0 ;
38053
38054   arg1 = (float)jarg1;
38055   {
38056     try {
38057       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38058     } catch (std::out_of_range& e) {
38059       {
38060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38061       };
38062     } catch (std::exception& e) {
38063       {
38064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38065       };
38066     } catch (...) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38069       };
38070     }
38071   }
38072   jresult = (void *)result;
38073   return jresult;
38074 }
38075
38076
38077 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38078   void * jresult ;
38079   float arg1 ;
38080   float arg2 ;
38081   Dali::TimePeriod *result = 0 ;
38082
38083   arg1 = (float)jarg1;
38084   arg2 = (float)jarg2;
38085   {
38086     try {
38087       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38088     } catch (std::out_of_range& e) {
38089       {
38090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38091       };
38092     } catch (std::exception& e) {
38093       {
38094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38095       };
38096     } catch (...) {
38097       {
38098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38099       };
38100     }
38101   }
38102   jresult = (void *)result;
38103   return jresult;
38104 }
38105
38106
38107 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TimePeriod(void * jarg1) {
38108   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38109
38110   arg1 = (Dali::TimePeriod *)jarg1;
38111   {
38112     try {
38113       delete arg1;
38114     } catch (std::out_of_range& e) {
38115       {
38116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38117       };
38118     } catch (std::exception& e) {
38119       {
38120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38121       };
38122     } catch (...) {
38123       {
38124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38125       };
38126     }
38127   }
38128 }
38129
38130
38131 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38132   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38133   float arg2 ;
38134
38135   arg1 = (Dali::TimePeriod *)jarg1;
38136   arg2 = (float)jarg2;
38137   if (arg1) (arg1)->delaySeconds = arg2;
38138 }
38139
38140
38141 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TimePeriod_delaySeconds_get(void * jarg1) {
38142   float jresult ;
38143   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38144   float result;
38145
38146   arg1 = (Dali::TimePeriod *)jarg1;
38147   result = (float) ((arg1)->delaySeconds);
38148   jresult = result;
38149   return jresult;
38150 }
38151
38152
38153 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38154   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38155   float arg2 ;
38156
38157   arg1 = (Dali::TimePeriod *)jarg1;
38158   arg2 = (float)jarg2;
38159   if (arg1) (arg1)->durationSeconds = arg2;
38160 }
38161
38162
38163 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TimePeriod_durationSeconds_get(void * jarg1) {
38164   float jresult ;
38165   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38166   float result;
38167
38168   arg1 = (Dali::TimePeriod *)jarg1;
38169   result = (float) ((arg1)->durationSeconds);
38170   jresult = result;
38171   return jresult;
38172 }
38173
38174
38175 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Animation__SWIG_0() {
38176   void * jresult ;
38177   Dali::Animation *result = 0 ;
38178
38179   {
38180     try {
38181       result = (Dali::Animation *)new Dali::Animation();
38182     } catch (std::out_of_range& e) {
38183       {
38184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38185       };
38186     } catch (std::exception& e) {
38187       {
38188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38193       };
38194     }
38195   }
38196   jresult = (void *)result;
38197   return jresult;
38198 }
38199
38200
38201 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_New(float jarg1) {
38202   void * jresult ;
38203   float arg1 ;
38204   Dali::Animation result;
38205
38206   arg1 = (float)jarg1;
38207   {
38208     try {
38209       result = Dali::Animation::New(arg1);
38210     } catch (std::out_of_range& e) {
38211       {
38212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38213       };
38214     } catch (std::exception& e) {
38215       {
38216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38217       };
38218     } catch (...) {
38219       {
38220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38221       };
38222     }
38223   }
38224   jresult = new Dali::Animation((const Dali::Animation &)result);
38225   return jresult;
38226 }
38227
38228
38229 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_DownCast(void * jarg1) {
38230   void * jresult ;
38231   Dali::BaseHandle arg1 ;
38232   Dali::BaseHandle *argp1 ;
38233   Dali::Animation result;
38234
38235   argp1 = (Dali::BaseHandle *)jarg1;
38236   if (!argp1) {
38237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38238     return 0;
38239   }
38240   arg1 = *argp1;
38241   {
38242     try {
38243       result = Dali::Animation::DownCast(arg1);
38244     } catch (std::out_of_range& e) {
38245       {
38246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38247       };
38248     } catch (std::exception& e) {
38249       {
38250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (...) {
38253       {
38254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38255       };
38256     }
38257   }
38258   jresult = new Dali::Animation((const Dali::Animation &)result);
38259   return jresult;
38260 }
38261
38262
38263 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Animation(void * jarg1) {
38264   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38265
38266   arg1 = (Dali::Animation *)jarg1;
38267   {
38268     try {
38269       delete arg1;
38270     } catch (std::out_of_range& e) {
38271       {
38272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38273       };
38274     } catch (std::exception& e) {
38275       {
38276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38277       };
38278     } catch (...) {
38279       {
38280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38281       };
38282     }
38283   }
38284 }
38285
38286
38287 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Animation__SWIG_1(void * jarg1) {
38288   void * jresult ;
38289   Dali::Animation *arg1 = 0 ;
38290   Dali::Animation *result = 0 ;
38291
38292   arg1 = (Dali::Animation *)jarg1;
38293   if (!arg1) {
38294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38295     return 0;
38296   }
38297   {
38298     try {
38299       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38300     } catch (std::out_of_range& e) {
38301       {
38302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38303       };
38304     } catch (std::exception& e) {
38305       {
38306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38307       };
38308     } catch (...) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38311       };
38312     }
38313   }
38314   jresult = (void *)result;
38315   return jresult;
38316 }
38317
38318
38319 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_Assign(void * jarg1, void * jarg2) {
38320   void * jresult ;
38321   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38322   Dali::Animation *arg2 = 0 ;
38323   Dali::Animation *result = 0 ;
38324
38325   arg1 = (Dali::Animation *)jarg1;
38326   arg2 = (Dali::Animation *)jarg2;
38327   if (!arg2) {
38328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38329     return 0;
38330   }
38331   {
38332     try {
38333       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDuration(void * jarg1, float jarg2) {
38354   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38355   float arg2 ;
38356
38357   arg1 = (Dali::Animation *)jarg1;
38358   arg2 = (float)jarg2;
38359   {
38360     try {
38361       (arg1)->SetDuration(arg2);
38362     } catch (std::out_of_range& e) {
38363       {
38364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38365       };
38366     } catch (std::exception& e) {
38367       {
38368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38369       };
38370     } catch (...) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38373       };
38374     }
38375   }
38376 }
38377
38378
38379 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetDuration(void * jarg1) {
38380   float jresult ;
38381   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38382   float result;
38383
38384   arg1 = (Dali::Animation *)jarg1;
38385   {
38386     try {
38387       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38388     } catch (std::out_of_range& e) {
38389       {
38390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38391       };
38392     } catch (std::exception& e) {
38393       {
38394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38395       };
38396     } catch (...) {
38397       {
38398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38399       };
38400     }
38401   }
38402   jresult = result;
38403   return jresult;
38404 }
38405
38406
38407 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38408   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38409   bool arg2 ;
38410
38411   arg1 = (Dali::Animation *)jarg1;
38412   arg2 = jarg2 ? true : false;
38413   {
38414     try {
38415       (arg1)->SetLooping(arg2);
38416     } catch (std::out_of_range& e) {
38417       {
38418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38419       };
38420     } catch (std::exception& e) {
38421       {
38422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38423       };
38424     } catch (...) {
38425       {
38426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38427       };
38428     }
38429   }
38430 }
38431
38432
38433 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetLoopCount(void * jarg1, int jarg2) {
38434   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38435   int arg2 ;
38436
38437   arg1 = (Dali::Animation *)jarg1;
38438   arg2 = (int)jarg2;
38439   {
38440     try {
38441       (arg1)->SetLoopCount(arg2);
38442     } catch (std::out_of_range& e) {
38443       {
38444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38445       };
38446     } catch (std::exception& e) {
38447       {
38448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38449       };
38450     } catch (...) {
38451       {
38452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38453       };
38454     }
38455   }
38456 }
38457
38458
38459 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetLoopCount(void * jarg1) {
38460   int jresult ;
38461   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38462   int result;
38463
38464   arg1 = (Dali::Animation *)jarg1;
38465   {
38466     try {
38467       result = (int)(arg1)->GetLoopCount();
38468     } catch (std::out_of_range& e) {
38469       {
38470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38471       };
38472     } catch (std::exception& e) {
38473       {
38474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38475       };
38476     } catch (...) {
38477       {
38478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38479       };
38480     }
38481   }
38482   jresult = result;
38483   return jresult;
38484 }
38485
38486
38487 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetCurrentLoop(void * jarg1) {
38488   int jresult ;
38489   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38490   int result;
38491
38492   arg1 = (Dali::Animation *)jarg1;
38493   {
38494     try {
38495       result = (int)(arg1)->GetCurrentLoop();
38496     } catch (std::out_of_range& e) {
38497       {
38498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38499       };
38500     } catch (std::exception& e) {
38501       {
38502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38503       };
38504     } catch (...) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38507       };
38508     }
38509   }
38510   jresult = result;
38511   return jresult;
38512 }
38513
38514
38515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Animation_IsLooping(void * jarg1) {
38516   unsigned int jresult ;
38517   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38518   bool result;
38519
38520   arg1 = (Dali::Animation *)jarg1;
38521   {
38522     try {
38523       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38524     } catch (std::out_of_range& e) {
38525       {
38526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (std::exception& e) {
38529       {
38530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38531       };
38532     } catch (...) {
38533       {
38534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38535       };
38536     }
38537   }
38538   jresult = result;
38539   return jresult;
38540 }
38541
38542
38543 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetEndAction(void * jarg1, int jarg2) {
38544   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38545   Dali::Animation::EndAction arg2 ;
38546
38547   arg1 = (Dali::Animation *)jarg1;
38548   arg2 = (Dali::Animation::EndAction)jarg2;
38549   {
38550     try {
38551       (arg1)->SetEndAction(arg2);
38552     } catch (std::out_of_range& e) {
38553       {
38554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38555       };
38556     } catch (std::exception& e) {
38557       {
38558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38559       };
38560     } catch (...) {
38561       {
38562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38563       };
38564     }
38565   }
38566 }
38567
38568
38569 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetEndAction(void * jarg1) {
38570   int jresult ;
38571   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38572   Dali::Animation::EndAction result;
38573
38574   arg1 = (Dali::Animation *)jarg1;
38575   {
38576     try {
38577       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38578     } catch (std::out_of_range& e) {
38579       {
38580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38581       };
38582     } catch (std::exception& e) {
38583       {
38584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38589       };
38590     }
38591   }
38592   jresult = (int)result;
38593   return jresult;
38594 }
38595
38596
38597 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38598   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38599   Dali::Animation::EndAction arg2 ;
38600
38601   arg1 = (Dali::Animation *)jarg1;
38602   arg2 = (Dali::Animation::EndAction)jarg2;
38603   {
38604     try {
38605       (arg1)->SetDisconnectAction(arg2);
38606     } catch (std::out_of_range& e) {
38607       {
38608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38609       };
38610     } catch (std::exception& e) {
38611       {
38612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38613       };
38614     } catch (...) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38617       };
38618     }
38619   }
38620 }
38621
38622
38623 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetDisconnectAction(void * jarg1) {
38624   int jresult ;
38625   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38626   Dali::Animation::EndAction result;
38627
38628   arg1 = (Dali::Animation *)jarg1;
38629   {
38630     try {
38631       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38632     } catch (std::out_of_range& e) {
38633       {
38634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38635       };
38636     } catch (std::exception& e) {
38637       {
38638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38639       };
38640     } catch (...) {
38641       {
38642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38643       };
38644     }
38645   }
38646   jresult = (int)result;
38647   return jresult;
38648 }
38649
38650
38651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38652   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38653   Dali::AlphaFunction arg2 ;
38654   Dali::AlphaFunction *argp2 ;
38655
38656   arg1 = (Dali::Animation *)jarg1;
38657   argp2 = (Dali::AlphaFunction *)jarg2;
38658   if (!argp2) {
38659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38660     return ;
38661   }
38662   arg2 = *argp2;
38663   {
38664     try {
38665       (arg1)->SetDefaultAlphaFunction(arg2);
38666     } catch (std::out_of_range& e) {
38667       {
38668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38669       };
38670     } catch (std::exception& e) {
38671       {
38672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38673       };
38674     } catch (...) {
38675       {
38676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38677       };
38678     }
38679   }
38680 }
38681
38682
38683 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_GetDefaultAlphaFunction(void * jarg1) {
38684   void * jresult ;
38685   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38686   Dali::AlphaFunction result;
38687
38688   arg1 = (Dali::Animation *)jarg1;
38689   {
38690     try {
38691       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38692     } catch (std::out_of_range& e) {
38693       {
38694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38695       };
38696     } catch (std::exception& e) {
38697       {
38698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38699       };
38700     } catch (...) {
38701       {
38702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38703       };
38704     }
38705   }
38706   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38707   return jresult;
38708 }
38709
38710
38711 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38712   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38713   float arg2 ;
38714
38715   arg1 = (Dali::Animation *)jarg1;
38716   arg2 = (float)jarg2;
38717   {
38718     try {
38719       (arg1)->SetCurrentProgress(arg2);
38720     } catch (std::out_of_range& e) {
38721       {
38722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38723       };
38724     } catch (std::exception& e) {
38725       {
38726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38727       };
38728     } catch (...) {
38729       {
38730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38731       };
38732     }
38733   }
38734 }
38735
38736
38737 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetCurrentProgress(void * jarg1) {
38738   float jresult ;
38739   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38740   float result;
38741
38742   arg1 = (Dali::Animation *)jarg1;
38743   {
38744     try {
38745       result = (float)(arg1)->GetCurrentProgress();
38746     } catch (std::out_of_range& e) {
38747       {
38748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38749       };
38750     } catch (std::exception& e) {
38751       {
38752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38757       };
38758     }
38759   }
38760   jresult = result;
38761   return jresult;
38762 }
38763
38764
38765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38766   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38767   float arg2 ;
38768
38769   arg1 = (Dali::Animation *)jarg1;
38770   arg2 = (float)jarg2;
38771   {
38772     try {
38773       (arg1)->SetSpeedFactor(arg2);
38774     } catch (std::out_of_range& e) {
38775       {
38776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38777       };
38778     } catch (std::exception& e) {
38779       {
38780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38781       };
38782     } catch (...) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38785       };
38786     }
38787   }
38788 }
38789
38790
38791 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetSpeedFactor(void * jarg1) {
38792   float jresult ;
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   float result;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   {
38798     try {
38799       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38807       };
38808     } catch (...) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38811       };
38812     }
38813   }
38814   jresult = result;
38815   return jresult;
38816 }
38817
38818
38819 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   Dali::Vector2 *arg2 = 0 ;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   arg2 = (Dali::Vector2 *)jarg2;
38825   if (!arg2) {
38826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38827     return ;
38828   }
38829   {
38830     try {
38831       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38832     } catch (std::out_of_range& e) {
38833       {
38834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38835       };
38836     } catch (std::exception& e) {
38837       {
38838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38839       };
38840     } catch (...) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38843       };
38844     }
38845   }
38846 }
38847
38848
38849 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_GetPlayRange(void * jarg1) {
38850   void * jresult ;
38851   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38852   Dali::Vector2 result;
38853
38854   arg1 = (Dali::Animation *)jarg1;
38855   {
38856     try {
38857       result = ((Dali::Animation const *)arg1)->GetPlayRange();
38858     } catch (std::out_of_range& e) {
38859       {
38860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (std::exception& e) {
38863       {
38864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38865       };
38866     } catch (...) {
38867       {
38868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38869       };
38870     }
38871   }
38872   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38873   return jresult;
38874 }
38875
38876
38877 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Play(void * jarg1) {
38878   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38879
38880   arg1 = (Dali::Animation *)jarg1;
38881   {
38882     try {
38883       (arg1)->Play();
38884     } catch (std::out_of_range& e) {
38885       {
38886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38887       };
38888     } catch (std::exception& e) {
38889       {
38890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38891       };
38892     } catch (...) {
38893       {
38894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38895       };
38896     }
38897   }
38898 }
38899
38900
38901 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_PlayFrom(void * jarg1, float jarg2) {
38902   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38903   float arg2 ;
38904
38905   arg1 = (Dali::Animation *)jarg1;
38906   arg2 = (float)jarg2;
38907   {
38908     try {
38909       (arg1)->PlayFrom(arg2);
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38921       };
38922     }
38923   }
38924 }
38925
38926
38927 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Pause(void * jarg1) {
38928   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38929
38930   arg1 = (Dali::Animation *)jarg1;
38931   {
38932     try {
38933       (arg1)->Pause();
38934     } catch (std::out_of_range& e) {
38935       {
38936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38937       };
38938     } catch (std::exception& e) {
38939       {
38940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38941       };
38942     } catch (...) {
38943       {
38944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38945       };
38946     }
38947   }
38948 }
38949
38950
38951 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetState(void * jarg1) {
38952   int jresult ;
38953   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38954   Dali::Animation::State result;
38955
38956   arg1 = (Dali::Animation *)jarg1;
38957   {
38958     try {
38959       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
38960     } catch (std::out_of_range& e) {
38961       {
38962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38963       };
38964     } catch (std::exception& e) {
38965       {
38966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38967       };
38968     } catch (...) {
38969       {
38970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38971       };
38972     }
38973   }
38974   jresult = (int)result;
38975   return jresult;
38976 }
38977
38978
38979 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Stop(void * jarg1) {
38980   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38981
38982   arg1 = (Dali::Animation *)jarg1;
38983   {
38984     try {
38985       (arg1)->Stop();
38986     } catch (std::out_of_range& e) {
38987       {
38988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38989       };
38990     } catch (std::exception& e) {
38991       {
38992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38993       };
38994     } catch (...) {
38995       {
38996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38997       };
38998     }
38999   }
39000 }
39001
39002
39003 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Clear(void * jarg1) {
39004   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39005
39006   arg1 = (Dali::Animation *)jarg1;
39007   {
39008     try {
39009       (arg1)->Clear();
39010     } catch (std::out_of_range& e) {
39011       {
39012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39013       };
39014     } catch (std::exception& e) {
39015       {
39016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39017       };
39018     } catch (...) {
39019       {
39020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39021       };
39022     }
39023   }
39024 }
39025
39026
39027 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_FinishedSignal(void * jarg1) {
39028   void * jresult ;
39029   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39030   Dali::Animation::AnimationSignalType *result = 0 ;
39031
39032   arg1 = (Dali::Animation *)jarg1;
39033   {
39034     try {
39035       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39036     } catch (std::out_of_range& e) {
39037       {
39038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39039       };
39040     } catch (std::exception& e) {
39041       {
39042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39043       };
39044     } catch (...) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39047       };
39048     }
39049   }
39050   jresult = (void *)result;
39051   return jresult;
39052 }
39053
39054
39055 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39056   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39057   SwigValueWrapper< Dali::Property > arg2 ;
39058   Dali::Property::Value arg3 ;
39059   Dali::Property *argp2 ;
39060   Dali::Property::Value *argp3 ;
39061
39062   arg1 = (Dali::Animation *)jarg1;
39063   argp2 = (Dali::Property *)jarg2;
39064   if (!argp2) {
39065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39066     return ;
39067   }
39068   arg2 = *argp2;
39069   argp3 = (Dali::Property::Value *)jarg3;
39070   if (!argp3) {
39071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39072     return ;
39073   }
39074   arg3 = *argp3;
39075   {
39076     try {
39077       (arg1)->AnimateBy(arg2,arg3);
39078     } catch (std::out_of_range& e) {
39079       {
39080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39081       };
39082     } catch (std::exception& e) {
39083       {
39084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39085       };
39086     } catch (...) {
39087       {
39088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39089       };
39090     }
39091   }
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39096   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39097   SwigValueWrapper< Dali::Property > arg2 ;
39098   Dali::Property::Value arg3 ;
39099   Dali::AlphaFunction arg4 ;
39100   Dali::Property *argp2 ;
39101   Dali::Property::Value *argp3 ;
39102   Dali::AlphaFunction *argp4 ;
39103
39104   arg1 = (Dali::Animation *)jarg1;
39105   argp2 = (Dali::Property *)jarg2;
39106   if (!argp2) {
39107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39108     return ;
39109   }
39110   arg2 = *argp2;
39111   argp3 = (Dali::Property::Value *)jarg3;
39112   if (!argp3) {
39113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39114     return ;
39115   }
39116   arg3 = *argp3;
39117   argp4 = (Dali::AlphaFunction *)jarg4;
39118   if (!argp4) {
39119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39120     return ;
39121   }
39122   arg4 = *argp4;
39123   {
39124     try {
39125       (arg1)->AnimateBy(arg2,arg3,arg4);
39126     } catch (std::out_of_range& e) {
39127       {
39128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39129       };
39130     } catch (std::exception& e) {
39131       {
39132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39133       };
39134     } catch (...) {
39135       {
39136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39137       };
39138     }
39139   }
39140 }
39141
39142
39143 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39144   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39145   SwigValueWrapper< Dali::Property > arg2 ;
39146   Dali::Property::Value arg3 ;
39147   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39148   Dali::Property *argp2 ;
39149   Dali::Property::Value *argp3 ;
39150   Dali::TimePeriod *argp4 ;
39151
39152   arg1 = (Dali::Animation *)jarg1;
39153   argp2 = (Dali::Property *)jarg2;
39154   if (!argp2) {
39155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39156     return ;
39157   }
39158   arg2 = *argp2;
39159   argp3 = (Dali::Property::Value *)jarg3;
39160   if (!argp3) {
39161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39162     return ;
39163   }
39164   arg3 = *argp3;
39165   argp4 = (Dali::TimePeriod *)jarg4;
39166   if (!argp4) {
39167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39168     return ;
39169   }
39170   arg4 = *argp4;
39171   {
39172     try {
39173       (arg1)->AnimateBy(arg2,arg3,arg4);
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39185       };
39186     }
39187   }
39188 }
39189
39190
39191 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39192   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39193   SwigValueWrapper< Dali::Property > arg2 ;
39194   Dali::Property::Value arg3 ;
39195   Dali::AlphaFunction arg4 ;
39196   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39197   Dali::Property *argp2 ;
39198   Dali::Property::Value *argp3 ;
39199   Dali::AlphaFunction *argp4 ;
39200   Dali::TimePeriod *argp5 ;
39201
39202   arg1 = (Dali::Animation *)jarg1;
39203   argp2 = (Dali::Property *)jarg2;
39204   if (!argp2) {
39205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39206     return ;
39207   }
39208   arg2 = *argp2;
39209   argp3 = (Dali::Property::Value *)jarg3;
39210   if (!argp3) {
39211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39212     return ;
39213   }
39214   arg3 = *argp3;
39215   argp4 = (Dali::AlphaFunction *)jarg4;
39216   if (!argp4) {
39217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39218     return ;
39219   }
39220   arg4 = *argp4;
39221   argp5 = (Dali::TimePeriod *)jarg5;
39222   if (!argp5) {
39223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39224     return ;
39225   }
39226   arg5 = *argp5;
39227   {
39228     try {
39229       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39230     } catch (std::out_of_range& e) {
39231       {
39232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39233       };
39234     } catch (std::exception& e) {
39235       {
39236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39237       };
39238     } catch (...) {
39239       {
39240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39241       };
39242     }
39243   }
39244 }
39245
39246
39247 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39248   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39249   SwigValueWrapper< Dali::Property > arg2 ;
39250   Dali::Property::Value arg3 ;
39251   Dali::Property *argp2 ;
39252   Dali::Property::Value *argp3 ;
39253
39254   arg1 = (Dali::Animation *)jarg1;
39255   argp2 = (Dali::Property *)jarg2;
39256   if (!argp2) {
39257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39258     return ;
39259   }
39260   arg2 = *argp2;
39261   argp3 = (Dali::Property::Value *)jarg3;
39262   if (!argp3) {
39263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39264     return ;
39265   }
39266   arg3 = *argp3;
39267   {
39268     try {
39269       (arg1)->AnimateTo(arg2,arg3);
39270     } catch (std::out_of_range& e) {
39271       {
39272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39273       };
39274     } catch (std::exception& e) {
39275       {
39276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39281       };
39282     }
39283   }
39284 }
39285
39286
39287 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39288   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39289   SwigValueWrapper< Dali::Property > arg2 ;
39290   Dali::Property::Value arg3 ;
39291   Dali::AlphaFunction arg4 ;
39292   Dali::Property *argp2 ;
39293   Dali::Property::Value *argp3 ;
39294   Dali::AlphaFunction *argp4 ;
39295
39296   arg1 = (Dali::Animation *)jarg1;
39297   argp2 = (Dali::Property *)jarg2;
39298   if (!argp2) {
39299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39300     return ;
39301   }
39302   arg2 = *argp2;
39303   argp3 = (Dali::Property::Value *)jarg3;
39304   if (!argp3) {
39305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39306     return ;
39307   }
39308   arg3 = *argp3;
39309   argp4 = (Dali::AlphaFunction *)jarg4;
39310   if (!argp4) {
39311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39312     return ;
39313   }
39314   arg4 = *argp4;
39315   {
39316     try {
39317       (arg1)->AnimateTo(arg2,arg3,arg4);
39318     } catch (std::out_of_range& e) {
39319       {
39320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39321       };
39322     } catch (std::exception& e) {
39323       {
39324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39325       };
39326     } catch (...) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39329       };
39330     }
39331   }
39332 }
39333
39334
39335 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39336   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39337   SwigValueWrapper< Dali::Property > arg2 ;
39338   Dali::Property::Value arg3 ;
39339   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39340   Dali::Property *argp2 ;
39341   Dali::Property::Value *argp3 ;
39342   Dali::TimePeriod *argp4 ;
39343
39344   arg1 = (Dali::Animation *)jarg1;
39345   argp2 = (Dali::Property *)jarg2;
39346   if (!argp2) {
39347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39348     return ;
39349   }
39350   arg2 = *argp2;
39351   argp3 = (Dali::Property::Value *)jarg3;
39352   if (!argp3) {
39353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39354     return ;
39355   }
39356   arg3 = *argp3;
39357   argp4 = (Dali::TimePeriod *)jarg4;
39358   if (!argp4) {
39359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39360     return ;
39361   }
39362   arg4 = *argp4;
39363   {
39364     try {
39365       (arg1)->AnimateTo(arg2,arg3,arg4);
39366     } catch (std::out_of_range& e) {
39367       {
39368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39369       };
39370     } catch (std::exception& e) {
39371       {
39372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (...) {
39375       {
39376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39377       };
39378     }
39379   }
39380 }
39381
39382
39383 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39384   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39385   SwigValueWrapper< Dali::Property > arg2 ;
39386   Dali::Property::Value arg3 ;
39387   Dali::AlphaFunction arg4 ;
39388   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39389   Dali::Property *argp2 ;
39390   Dali::Property::Value *argp3 ;
39391   Dali::AlphaFunction *argp4 ;
39392   Dali::TimePeriod *argp5 ;
39393
39394   arg1 = (Dali::Animation *)jarg1;
39395   argp2 = (Dali::Property *)jarg2;
39396   if (!argp2) {
39397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39398     return ;
39399   }
39400   arg2 = *argp2;
39401   argp3 = (Dali::Property::Value *)jarg3;
39402   if (!argp3) {
39403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39404     return ;
39405   }
39406   arg3 = *argp3;
39407   argp4 = (Dali::AlphaFunction *)jarg4;
39408   if (!argp4) {
39409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39410     return ;
39411   }
39412   arg4 = *argp4;
39413   argp5 = (Dali::TimePeriod *)jarg5;
39414   if (!argp5) {
39415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39416     return ;
39417   }
39418   arg5 = *argp5;
39419   {
39420     try {
39421       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39422     } catch (std::out_of_range& e) {
39423       {
39424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39425       };
39426     } catch (std::exception& e) {
39427       {
39428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39429       };
39430     } catch (...) {
39431       {
39432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39433       };
39434     }
39435   }
39436 }
39437
39438
39439 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39440   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39441   SwigValueWrapper< Dali::Property > arg2 ;
39442   Dali::KeyFrames *arg3 = 0 ;
39443   Dali::Property *argp2 ;
39444
39445   arg1 = (Dali::Animation *)jarg1;
39446   argp2 = (Dali::Property *)jarg2;
39447   if (!argp2) {
39448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39449     return ;
39450   }
39451   arg2 = *argp2;
39452   arg3 = (Dali::KeyFrames *)jarg3;
39453   if (!arg3) {
39454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39455     return ;
39456   }
39457   {
39458     try {
39459       (arg1)->AnimateBetween(arg2,*arg3);
39460     } catch (std::out_of_range& e) {
39461       {
39462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39463       };
39464     } catch (std::exception& e) {
39465       {
39466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39467       };
39468     } catch (...) {
39469       {
39470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39471       };
39472     }
39473   }
39474 }
39475
39476
39477 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39478   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39479   SwigValueWrapper< Dali::Property > arg2 ;
39480   Dali::KeyFrames *arg3 = 0 ;
39481   Dali::Animation::Interpolation arg4 ;
39482   Dali::Property *argp2 ;
39483
39484   arg1 = (Dali::Animation *)jarg1;
39485   argp2 = (Dali::Property *)jarg2;
39486   if (!argp2) {
39487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39488     return ;
39489   }
39490   arg2 = *argp2;
39491   arg3 = (Dali::KeyFrames *)jarg3;
39492   if (!arg3) {
39493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39494     return ;
39495   }
39496   arg4 = (Dali::Animation::Interpolation)jarg4;
39497   {
39498     try {
39499       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39500     } catch (std::out_of_range& e) {
39501       {
39502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39503       };
39504     } catch (std::exception& e) {
39505       {
39506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39507       };
39508     } catch (...) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39511       };
39512     }
39513   }
39514 }
39515
39516
39517 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39518   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39519   SwigValueWrapper< Dali::Property > arg2 ;
39520   Dali::KeyFrames *arg3 = 0 ;
39521   Dali::AlphaFunction arg4 ;
39522   Dali::Property *argp2 ;
39523   Dali::AlphaFunction *argp4 ;
39524
39525   arg1 = (Dali::Animation *)jarg1;
39526   argp2 = (Dali::Property *)jarg2;
39527   if (!argp2) {
39528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39529     return ;
39530   }
39531   arg2 = *argp2;
39532   arg3 = (Dali::KeyFrames *)jarg3;
39533   if (!arg3) {
39534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39535     return ;
39536   }
39537   argp4 = (Dali::AlphaFunction *)jarg4;
39538   if (!argp4) {
39539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39540     return ;
39541   }
39542   arg4 = *argp4;
39543   {
39544     try {
39545       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39546     } catch (std::out_of_range& e) {
39547       {
39548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39549       };
39550     } catch (std::exception& e) {
39551       {
39552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39553       };
39554     } catch (...) {
39555       {
39556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39557       };
39558     }
39559   }
39560 }
39561
39562
39563 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39564   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39565   SwigValueWrapper< Dali::Property > arg2 ;
39566   Dali::KeyFrames *arg3 = 0 ;
39567   Dali::AlphaFunction arg4 ;
39568   Dali::Animation::Interpolation arg5 ;
39569   Dali::Property *argp2 ;
39570   Dali::AlphaFunction *argp4 ;
39571
39572   arg1 = (Dali::Animation *)jarg1;
39573   argp2 = (Dali::Property *)jarg2;
39574   if (!argp2) {
39575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39576     return ;
39577   }
39578   arg2 = *argp2;
39579   arg3 = (Dali::KeyFrames *)jarg3;
39580   if (!arg3) {
39581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39582     return ;
39583   }
39584   argp4 = (Dali::AlphaFunction *)jarg4;
39585   if (!argp4) {
39586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39587     return ;
39588   }
39589   arg4 = *argp4;
39590   arg5 = (Dali::Animation::Interpolation)jarg5;
39591   {
39592     try {
39593       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39594     } catch (std::out_of_range& e) {
39595       {
39596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39597       };
39598     } catch (std::exception& e) {
39599       {
39600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39601       };
39602     } catch (...) {
39603       {
39604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39605       };
39606     }
39607   }
39608 }
39609
39610
39611 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39612   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39613   SwigValueWrapper< Dali::Property > arg2 ;
39614   Dali::KeyFrames *arg3 = 0 ;
39615   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39616   Dali::Property *argp2 ;
39617   Dali::TimePeriod *argp4 ;
39618
39619   arg1 = (Dali::Animation *)jarg1;
39620   argp2 = (Dali::Property *)jarg2;
39621   if (!argp2) {
39622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39623     return ;
39624   }
39625   arg2 = *argp2;
39626   arg3 = (Dali::KeyFrames *)jarg3;
39627   if (!arg3) {
39628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39629     return ;
39630   }
39631   argp4 = (Dali::TimePeriod *)jarg4;
39632   if (!argp4) {
39633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39634     return ;
39635   }
39636   arg4 = *argp4;
39637   {
39638     try {
39639       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39640     } catch (std::out_of_range& e) {
39641       {
39642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39643       };
39644     } catch (std::exception& e) {
39645       {
39646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39647       };
39648     } catch (...) {
39649       {
39650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39651       };
39652     }
39653   }
39654 }
39655
39656
39657 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39658   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39659   SwigValueWrapper< Dali::Property > arg2 ;
39660   Dali::KeyFrames *arg3 = 0 ;
39661   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39662   Dali::Animation::Interpolation arg5 ;
39663   Dali::Property *argp2 ;
39664   Dali::TimePeriod *argp4 ;
39665
39666   arg1 = (Dali::Animation *)jarg1;
39667   argp2 = (Dali::Property *)jarg2;
39668   if (!argp2) {
39669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39670     return ;
39671   }
39672   arg2 = *argp2;
39673   arg3 = (Dali::KeyFrames *)jarg3;
39674   if (!arg3) {
39675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39676     return ;
39677   }
39678   argp4 = (Dali::TimePeriod *)jarg4;
39679   if (!argp4) {
39680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39681     return ;
39682   }
39683   arg4 = *argp4;
39684   arg5 = (Dali::Animation::Interpolation)jarg5;
39685   {
39686     try {
39687       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39688     } catch (std::out_of_range& e) {
39689       {
39690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39691       };
39692     } catch (std::exception& e) {
39693       {
39694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39695       };
39696     } catch (...) {
39697       {
39698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39699       };
39700     }
39701   }
39702 }
39703
39704
39705 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39706   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39707   SwigValueWrapper< Dali::Property > arg2 ;
39708   Dali::KeyFrames *arg3 = 0 ;
39709   Dali::AlphaFunction arg4 ;
39710   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39711   Dali::Property *argp2 ;
39712   Dali::AlphaFunction *argp4 ;
39713   Dali::TimePeriod *argp5 ;
39714
39715   arg1 = (Dali::Animation *)jarg1;
39716   argp2 = (Dali::Property *)jarg2;
39717   if (!argp2) {
39718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39719     return ;
39720   }
39721   arg2 = *argp2;
39722   arg3 = (Dali::KeyFrames *)jarg3;
39723   if (!arg3) {
39724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39725     return ;
39726   }
39727   argp4 = (Dali::AlphaFunction *)jarg4;
39728   if (!argp4) {
39729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39730     return ;
39731   }
39732   arg4 = *argp4;
39733   argp5 = (Dali::TimePeriod *)jarg5;
39734   if (!argp5) {
39735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39736     return ;
39737   }
39738   arg5 = *argp5;
39739   {
39740     try {
39741       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39742     } catch (std::out_of_range& e) {
39743       {
39744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39745       };
39746     } catch (std::exception& e) {
39747       {
39748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39749       };
39750     } catch (...) {
39751       {
39752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39753       };
39754     }
39755   }
39756 }
39757
39758
39759 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39760   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39761   SwigValueWrapper< Dali::Property > arg2 ;
39762   Dali::KeyFrames *arg3 = 0 ;
39763   Dali::AlphaFunction arg4 ;
39764   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39765   Dali::Animation::Interpolation arg6 ;
39766   Dali::Property *argp2 ;
39767   Dali::AlphaFunction *argp4 ;
39768   Dali::TimePeriod *argp5 ;
39769
39770   arg1 = (Dali::Animation *)jarg1;
39771   argp2 = (Dali::Property *)jarg2;
39772   if (!argp2) {
39773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39774     return ;
39775   }
39776   arg2 = *argp2;
39777   arg3 = (Dali::KeyFrames *)jarg3;
39778   if (!arg3) {
39779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39780     return ;
39781   }
39782   argp4 = (Dali::AlphaFunction *)jarg4;
39783   if (!argp4) {
39784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39785     return ;
39786   }
39787   arg4 = *argp4;
39788   argp5 = (Dali::TimePeriod *)jarg5;
39789   if (!argp5) {
39790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39791     return ;
39792   }
39793   arg5 = *argp5;
39794   arg6 = (Dali::Animation::Interpolation)jarg6;
39795   {
39796     try {
39797       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39798     } catch (std::out_of_range& e) {
39799       {
39800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39801       };
39802     } catch (std::exception& e) {
39803       {
39804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39805       };
39806     } catch (...) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39809       };
39810     }
39811   }
39812 }
39813
39814
39815 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39816   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39817   Dali::Actor arg2 ;
39818   Dali::Path arg3 ;
39819   Dali::Vector3 *arg4 = 0 ;
39820   Dali::Actor *argp2 ;
39821   Dali::Path *argp3 ;
39822
39823   arg1 = (Dali::Animation *)jarg1;
39824   argp2 = (Dali::Actor *)jarg2;
39825   if (!argp2) {
39826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39827     return ;
39828   }
39829   arg2 = *argp2;
39830   argp3 = (Dali::Path *)jarg3;
39831   if (!argp3) {
39832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39833     return ;
39834   }
39835   arg3 = *argp3;
39836   arg4 = (Dali::Vector3 *)jarg4;
39837   if (!arg4) {
39838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39839     return ;
39840   }
39841   {
39842     try {
39843       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
39844     } catch (std::out_of_range& e) {
39845       {
39846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39847       };
39848     } catch (std::exception& e) {
39849       {
39850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39851       };
39852     } catch (...) {
39853       {
39854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39855       };
39856     }
39857   }
39858 }
39859
39860
39861 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39862   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39863   Dali::Actor arg2 ;
39864   Dali::Path arg3 ;
39865   Dali::Vector3 *arg4 = 0 ;
39866   Dali::AlphaFunction arg5 ;
39867   Dali::Actor *argp2 ;
39868   Dali::Path *argp3 ;
39869   Dali::AlphaFunction *argp5 ;
39870
39871   arg1 = (Dali::Animation *)jarg1;
39872   argp2 = (Dali::Actor *)jarg2;
39873   if (!argp2) {
39874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39875     return ;
39876   }
39877   arg2 = *argp2;
39878   argp3 = (Dali::Path *)jarg3;
39879   if (!argp3) {
39880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39881     return ;
39882   }
39883   arg3 = *argp3;
39884   arg4 = (Dali::Vector3 *)jarg4;
39885   if (!arg4) {
39886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39887     return ;
39888   }
39889   argp5 = (Dali::AlphaFunction *)jarg5;
39890   if (!argp5) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39892     return ;
39893   }
39894   arg5 = *argp5;
39895   {
39896     try {
39897       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39898     } catch (std::out_of_range& e) {
39899       {
39900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39901       };
39902     } catch (std::exception& e) {
39903       {
39904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39905       };
39906     } catch (...) {
39907       {
39908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39909       };
39910     }
39911   }
39912 }
39913
39914
39915 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39916   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39917   Dali::Actor arg2 ;
39918   Dali::Path arg3 ;
39919   Dali::Vector3 *arg4 = 0 ;
39920   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39921   Dali::Actor *argp2 ;
39922   Dali::Path *argp3 ;
39923   Dali::TimePeriod *argp5 ;
39924
39925   arg1 = (Dali::Animation *)jarg1;
39926   argp2 = (Dali::Actor *)jarg2;
39927   if (!argp2) {
39928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39929     return ;
39930   }
39931   arg2 = *argp2;
39932   argp3 = (Dali::Path *)jarg3;
39933   if (!argp3) {
39934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39935     return ;
39936   }
39937   arg3 = *argp3;
39938   arg4 = (Dali::Vector3 *)jarg4;
39939   if (!arg4) {
39940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39941     return ;
39942   }
39943   argp5 = (Dali::TimePeriod *)jarg5;
39944   if (!argp5) {
39945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39946     return ;
39947   }
39948   arg5 = *argp5;
39949   {
39950     try {
39951       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39959       };
39960     } catch (...) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39963       };
39964     }
39965   }
39966 }
39967
39968
39969 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
39970   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39971   Dali::Actor arg2 ;
39972   Dali::Path arg3 ;
39973   Dali::Vector3 *arg4 = 0 ;
39974   Dali::AlphaFunction arg5 ;
39975   SwigValueWrapper< Dali::TimePeriod > arg6 ;
39976   Dali::Actor *argp2 ;
39977   Dali::Path *argp3 ;
39978   Dali::AlphaFunction *argp5 ;
39979   Dali::TimePeriod *argp6 ;
39980
39981   arg1 = (Dali::Animation *)jarg1;
39982   argp2 = (Dali::Actor *)jarg2;
39983   if (!argp2) {
39984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39985     return ;
39986   }
39987   arg2 = *argp2;
39988   argp3 = (Dali::Path *)jarg3;
39989   if (!argp3) {
39990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39991     return ;
39992   }
39993   arg3 = *argp3;
39994   arg4 = (Dali::Vector3 *)jarg4;
39995   if (!arg4) {
39996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39997     return ;
39998   }
39999   argp5 = (Dali::AlphaFunction *)jarg5;
40000   if (!argp5) {
40001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40002     return ;
40003   }
40004   arg5 = *argp5;
40005   argp6 = (Dali::TimePeriod *)jarg6;
40006   if (!argp6) {
40007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40008     return ;
40009   }
40010   arg6 = *argp6;
40011   {
40012     try {
40013       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40014     } catch (std::out_of_range& e) {
40015       {
40016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40017       };
40018     } catch (std::exception& e) {
40019       {
40020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40021       };
40022     } catch (...) {
40023       {
40024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40025       };
40026     }
40027   }
40028 }
40029
40030
40031 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40032   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40033   Dali::Actor arg2 ;
40034   float arg3 ;
40035   Dali::Actor *argp2 ;
40036
40037   arg1 = (Dali::Animation *)jarg1;
40038   argp2 = (Dali::Actor *)jarg2;
40039   if (!argp2) {
40040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40041     return ;
40042   }
40043   arg2 = *argp2;
40044   arg3 = (float)jarg3;
40045   {
40046     try {
40047       (arg1)->Show(arg2,arg3);
40048     } catch (std::out_of_range& e) {
40049       {
40050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40051       };
40052     } catch (std::exception& e) {
40053       {
40054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40055       };
40056     } catch (...) {
40057       {
40058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40059       };
40060     }
40061   }
40062 }
40063
40064
40065 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40066   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40067   Dali::Actor arg2 ;
40068   float arg3 ;
40069   Dali::Actor *argp2 ;
40070
40071   arg1 = (Dali::Animation *)jarg1;
40072   argp2 = (Dali::Actor *)jarg2;
40073   if (!argp2) {
40074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40075     return ;
40076   }
40077   arg2 = *argp2;
40078   arg3 = (float)jarg3;
40079   {
40080     try {
40081       (arg1)->Hide(arg2,arg3);
40082     } catch (std::out_of_range& e) {
40083       {
40084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40085       };
40086     } catch (std::exception& e) {
40087       {
40088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40089       };
40090     } catch (...) {
40091       {
40092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40093       };
40094     }
40095   }
40096 }
40097
40098
40099 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LinearConstrainer_Property_VALUE_get() {
40100   int jresult ;
40101   int result;
40102
40103   result = (int)Dali::LinearConstrainer::Property::VALUE;
40104   jresult = (int)result;
40105   return jresult;
40106 }
40107
40108
40109 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LinearConstrainer_Property_PROGRESS_get() {
40110   int jresult ;
40111   int result;
40112
40113   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40114   jresult = (int)result;
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer_Property() {
40120   void * jresult ;
40121   Dali::LinearConstrainer::Property *result = 0 ;
40122
40123   {
40124     try {
40125       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40126     } catch (std::out_of_range& e) {
40127       {
40128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (std::exception& e) {
40131       {
40132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (...) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40137       };
40138     }
40139   }
40140   jresult = (void *)result;
40141   return jresult;
40142 }
40143
40144
40145 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LinearConstrainer_Property(void * jarg1) {
40146   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40147
40148   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40149   {
40150     try {
40151       delete arg1;
40152     } catch (std::out_of_range& e) {
40153       {
40154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40155       };
40156     } catch (std::exception& e) {
40157       {
40158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40163       };
40164     }
40165   }
40166 }
40167
40168
40169 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_New() {
40170   void * jresult ;
40171   Dali::LinearConstrainer result;
40172
40173   {
40174     try {
40175       result = Dali::LinearConstrainer::New();
40176     } catch (std::out_of_range& e) {
40177       {
40178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40179       };
40180     } catch (std::exception& e) {
40181       {
40182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40183       };
40184     } catch (...) {
40185       {
40186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40187       };
40188     }
40189   }
40190   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40191   return jresult;
40192 }
40193
40194
40195 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_DownCast(void * jarg1) {
40196   void * jresult ;
40197   Dali::BaseHandle arg1 ;
40198   Dali::BaseHandle *argp1 ;
40199   Dali::LinearConstrainer result;
40200
40201   argp1 = (Dali::BaseHandle *)jarg1;
40202   if (!argp1) {
40203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40204     return 0;
40205   }
40206   arg1 = *argp1;
40207   {
40208     try {
40209       result = Dali::LinearConstrainer::DownCast(arg1);
40210     } catch (std::out_of_range& e) {
40211       {
40212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40213       };
40214     } catch (std::exception& e) {
40215       {
40216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40217       };
40218     } catch (...) {
40219       {
40220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40221       };
40222     }
40223   }
40224   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40225   return jresult;
40226 }
40227
40228
40229 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer__SWIG_0() {
40230   void * jresult ;
40231   Dali::LinearConstrainer *result = 0 ;
40232
40233   {
40234     try {
40235       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40236     } catch (std::out_of_range& e) {
40237       {
40238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40239       };
40240     } catch (std::exception& e) {
40241       {
40242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40243       };
40244     } catch (...) {
40245       {
40246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40247       };
40248     }
40249   }
40250   jresult = (void *)result;
40251   return jresult;
40252 }
40253
40254
40255 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LinearConstrainer(void * jarg1) {
40256   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40257
40258   arg1 = (Dali::LinearConstrainer *)jarg1;
40259   {
40260     try {
40261       delete arg1;
40262     } catch (std::out_of_range& e) {
40263       {
40264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40265       };
40266     } catch (std::exception& e) {
40267       {
40268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40269       };
40270     } catch (...) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40273       };
40274     }
40275   }
40276 }
40277
40278
40279 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer__SWIG_1(void * jarg1) {
40280   void * jresult ;
40281   Dali::LinearConstrainer *arg1 = 0 ;
40282   Dali::LinearConstrainer *result = 0 ;
40283
40284   arg1 = (Dali::LinearConstrainer *)jarg1;
40285   if (!arg1) {
40286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40287     return 0;
40288   }
40289   {
40290     try {
40291       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40292     } catch (std::out_of_range& e) {
40293       {
40294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40295       };
40296     } catch (std::exception& e) {
40297       {
40298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40299       };
40300     } catch (...) {
40301       {
40302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40303       };
40304     }
40305   }
40306   jresult = (void *)result;
40307   return jresult;
40308 }
40309
40310
40311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40312   void * jresult ;
40313   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40314   Dali::LinearConstrainer *arg2 = 0 ;
40315   Dali::LinearConstrainer *result = 0 ;
40316
40317   arg1 = (Dali::LinearConstrainer *)jarg1;
40318   arg2 = (Dali::LinearConstrainer *)jarg2;
40319   if (!arg2) {
40320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40321     return 0;
40322   }
40323   {
40324     try {
40325       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40326     } catch (std::out_of_range& e) {
40327       {
40328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40329       };
40330     } catch (std::exception& e) {
40331       {
40332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40333       };
40334     } catch (...) {
40335       {
40336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40337       };
40338     }
40339   }
40340   jresult = (void *)result;
40341   return jresult;
40342 }
40343
40344
40345 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40346   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40347   SwigValueWrapper< Dali::Property > arg2 ;
40348   SwigValueWrapper< Dali::Property > arg3 ;
40349   Dali::Vector2 *arg4 = 0 ;
40350   Dali::Vector2 *arg5 = 0 ;
40351   Dali::Property *argp2 ;
40352   Dali::Property *argp3 ;
40353
40354   arg1 = (Dali::LinearConstrainer *)jarg1;
40355   argp2 = (Dali::Property *)jarg2;
40356   if (!argp2) {
40357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40358     return ;
40359   }
40360   arg2 = *argp2;
40361   argp3 = (Dali::Property *)jarg3;
40362   if (!argp3) {
40363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40364     return ;
40365   }
40366   arg3 = *argp3;
40367   arg4 = (Dali::Vector2 *)jarg4;
40368   if (!arg4) {
40369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40370     return ;
40371   }
40372   arg5 = (Dali::Vector2 *)jarg5;
40373   if (!arg5) {
40374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40375     return ;
40376   }
40377   {
40378     try {
40379       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40380     } catch (std::out_of_range& e) {
40381       {
40382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40383       };
40384     } catch (std::exception& e) {
40385       {
40386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40387       };
40388     } catch (...) {
40389       {
40390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40391       };
40392     }
40393   }
40394 }
40395
40396
40397 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40398   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40399   SwigValueWrapper< Dali::Property > arg2 ;
40400   SwigValueWrapper< Dali::Property > arg3 ;
40401   Dali::Vector2 *arg4 = 0 ;
40402   Dali::Property *argp2 ;
40403   Dali::Property *argp3 ;
40404
40405   arg1 = (Dali::LinearConstrainer *)jarg1;
40406   argp2 = (Dali::Property *)jarg2;
40407   if (!argp2) {
40408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40409     return ;
40410   }
40411   arg2 = *argp2;
40412   argp3 = (Dali::Property *)jarg3;
40413   if (!argp3) {
40414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40415     return ;
40416   }
40417   arg3 = *argp3;
40418   arg4 = (Dali::Vector2 *)jarg4;
40419   if (!arg4) {
40420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40421     return ;
40422   }
40423   {
40424     try {
40425       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40426     } catch (std::out_of_range& e) {
40427       {
40428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40429       };
40430     } catch (std::exception& e) {
40431       {
40432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40433       };
40434     } catch (...) {
40435       {
40436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40437       };
40438     }
40439   }
40440 }
40441
40442
40443 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40444   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40445   Dali::Handle *arg2 = 0 ;
40446
40447   arg1 = (Dali::LinearConstrainer *)jarg1;
40448   arg2 = (Dali::Handle *)jarg2;
40449   if (!arg2) {
40450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40451     return ;
40452   }
40453   {
40454     try {
40455       (arg1)->Remove(*arg2);
40456     } catch (std::out_of_range& e) {
40457       {
40458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40459       };
40460     } catch (std::exception& e) {
40461       {
40462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40463       };
40464     } catch (...) {
40465       {
40466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40467       };
40468     }
40469   }
40470 }
40471
40472
40473 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_FORWARD_get() {
40474   int jresult ;
40475   int result;
40476
40477   result = (int)Dali::PathConstrainer::Property::FORWARD;
40478   jresult = (int)result;
40479   return jresult;
40480 }
40481
40482
40483 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_POINTS_get() {
40484   int jresult ;
40485   int result;
40486
40487   result = (int)Dali::PathConstrainer::Property::POINTS;
40488   jresult = (int)result;
40489   return jresult;
40490 }
40491
40492
40493 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_CONTROL_POINTS_get() {
40494   int jresult ;
40495   int result;
40496
40497   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40498   jresult = (int)result;
40499   return jresult;
40500 }
40501
40502
40503 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer_Property() {
40504   void * jresult ;
40505   Dali::PathConstrainer::Property *result = 0 ;
40506
40507   {
40508     try {
40509       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40510     } catch (std::out_of_range& e) {
40511       {
40512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40513       };
40514     } catch (std::exception& e) {
40515       {
40516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40521       };
40522     }
40523   }
40524   jresult = (void *)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PathConstrainer_Property(void * jarg1) {
40530   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40531
40532   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40533   {
40534     try {
40535       delete arg1;
40536     } catch (std::out_of_range& e) {
40537       {
40538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40539       };
40540     } catch (std::exception& e) {
40541       {
40542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40547       };
40548     }
40549   }
40550 }
40551
40552
40553 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_New() {
40554   void * jresult ;
40555   Dali::PathConstrainer result;
40556
40557   {
40558     try {
40559       result = Dali::PathConstrainer::New();
40560     } catch (std::out_of_range& e) {
40561       {
40562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40563       };
40564     } catch (std::exception& e) {
40565       {
40566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (...) {
40569       {
40570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40571       };
40572     }
40573   }
40574   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40575   return jresult;
40576 }
40577
40578
40579 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_DownCast(void * jarg1) {
40580   void * jresult ;
40581   Dali::BaseHandle arg1 ;
40582   Dali::BaseHandle *argp1 ;
40583   Dali::PathConstrainer result;
40584
40585   argp1 = (Dali::BaseHandle *)jarg1;
40586   if (!argp1) {
40587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40588     return 0;
40589   }
40590   arg1 = *argp1;
40591   {
40592     try {
40593       result = Dali::PathConstrainer::DownCast(arg1);
40594     } catch (std::out_of_range& e) {
40595       {
40596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40597       };
40598     } catch (std::exception& e) {
40599       {
40600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (...) {
40603       {
40604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40605       };
40606     }
40607   }
40608   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40609   return jresult;
40610 }
40611
40612
40613 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer__SWIG_0() {
40614   void * jresult ;
40615   Dali::PathConstrainer *result = 0 ;
40616
40617   {
40618     try {
40619       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40620     } catch (std::out_of_range& e) {
40621       {
40622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40623       };
40624     } catch (std::exception& e) {
40625       {
40626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40627       };
40628     } catch (...) {
40629       {
40630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40631       };
40632     }
40633   }
40634   jresult = (void *)result;
40635   return jresult;
40636 }
40637
40638
40639 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PathConstrainer(void * jarg1) {
40640   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40641
40642   arg1 = (Dali::PathConstrainer *)jarg1;
40643   {
40644     try {
40645       delete arg1;
40646     } catch (std::out_of_range& e) {
40647       {
40648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40649       };
40650     } catch (std::exception& e) {
40651       {
40652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40653       };
40654     } catch (...) {
40655       {
40656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40657       };
40658     }
40659   }
40660 }
40661
40662
40663 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer__SWIG_1(void * jarg1) {
40664   void * jresult ;
40665   Dali::PathConstrainer *arg1 = 0 ;
40666   Dali::PathConstrainer *result = 0 ;
40667
40668   arg1 = (Dali::PathConstrainer *)jarg1;
40669   if (!arg1) {
40670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40671     return 0;
40672   }
40673   {
40674     try {
40675       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40676     } catch (std::out_of_range& e) {
40677       {
40678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40679       };
40680     } catch (std::exception& e) {
40681       {
40682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40683       };
40684     } catch (...) {
40685       {
40686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40687       };
40688     }
40689   }
40690   jresult = (void *)result;
40691   return jresult;
40692 }
40693
40694
40695 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40696   void * jresult ;
40697   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40698   Dali::PathConstrainer *arg2 = 0 ;
40699   Dali::PathConstrainer *result = 0 ;
40700
40701   arg1 = (Dali::PathConstrainer *)jarg1;
40702   arg2 = (Dali::PathConstrainer *)jarg2;
40703   if (!arg2) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40705     return 0;
40706   }
40707   {
40708     try {
40709       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40710     } catch (std::out_of_range& e) {
40711       {
40712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40713       };
40714     } catch (std::exception& e) {
40715       {
40716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40717       };
40718     } catch (...) {
40719       {
40720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40721       };
40722     }
40723   }
40724   jresult = (void *)result;
40725   return jresult;
40726 }
40727
40728
40729 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40730   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40731   SwigValueWrapper< Dali::Property > arg2 ;
40732   SwigValueWrapper< Dali::Property > arg3 ;
40733   Dali::Vector2 *arg4 = 0 ;
40734   Dali::Vector2 *arg5 = 0 ;
40735   Dali::Property *argp2 ;
40736   Dali::Property *argp3 ;
40737
40738   arg1 = (Dali::PathConstrainer *)jarg1;
40739   argp2 = (Dali::Property *)jarg2;
40740   if (!argp2) {
40741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40742     return ;
40743   }
40744   arg2 = *argp2;
40745   argp3 = (Dali::Property *)jarg3;
40746   if (!argp3) {
40747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40748     return ;
40749   }
40750   arg3 = *argp3;
40751   arg4 = (Dali::Vector2 *)jarg4;
40752   if (!arg4) {
40753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40754     return ;
40755   }
40756   arg5 = (Dali::Vector2 *)jarg5;
40757   if (!arg5) {
40758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40759     return ;
40760   }
40761   {
40762     try {
40763       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40764     } catch (std::out_of_range& e) {
40765       {
40766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40767       };
40768     } catch (std::exception& e) {
40769       {
40770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40771       };
40772     } catch (...) {
40773       {
40774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40775       };
40776     }
40777   }
40778 }
40779
40780
40781 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40782   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40783   SwigValueWrapper< Dali::Property > arg2 ;
40784   SwigValueWrapper< Dali::Property > arg3 ;
40785   Dali::Vector2 *arg4 = 0 ;
40786   Dali::Property *argp2 ;
40787   Dali::Property *argp3 ;
40788
40789   arg1 = (Dali::PathConstrainer *)jarg1;
40790   argp2 = (Dali::Property *)jarg2;
40791   if (!argp2) {
40792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40793     return ;
40794   }
40795   arg2 = *argp2;
40796   argp3 = (Dali::Property *)jarg3;
40797   if (!argp3) {
40798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40799     return ;
40800   }
40801   arg3 = *argp3;
40802   arg4 = (Dali::Vector2 *)jarg4;
40803   if (!arg4) {
40804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40805     return ;
40806   }
40807   {
40808     try {
40809       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40810     } catch (std::out_of_range& e) {
40811       {
40812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40813       };
40814     } catch (std::exception& e) {
40815       {
40816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (...) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40821       };
40822     }
40823   }
40824 }
40825
40826
40827 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40828   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40829   Dali::Handle *arg2 = 0 ;
40830
40831   arg1 = (Dali::PathConstrainer *)jarg1;
40832   arg2 = (Dali::Handle *)jarg2;
40833   if (!arg2) {
40834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40835     return ;
40836   }
40837   {
40838     try {
40839       (arg1)->Remove(*arg2);
40840     } catch (std::out_of_range& e) {
40841       {
40842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40843       };
40844     } catch (std::exception& e) {
40845       {
40846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40847       };
40848     } catch (...) {
40849       {
40850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40851       };
40852     }
40853   }
40854 }
40855
40856
40857 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FittingModeDefault_get() {
40858   int jresult ;
40859   Dali::FittingMode::Type result;
40860
40861   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
40862   jresult = (int)result;
40863   return jresult;
40864 }
40865
40866
40867 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_DEFAULT_get() {
40868   int jresult ;
40869   Dali::SamplingMode::Type result;
40870
40871   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
40872   jresult = (int)result;
40873   return jresult;
40874 }
40875
40876
40877 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BufferImage__SWIG_0() {
40878   void * jresult ;
40879   Dali::BufferImage *result = 0 ;
40880
40881   {
40882     try {
40883       result = (Dali::BufferImage *)new Dali::BufferImage();
40884     } catch (std::out_of_range& e) {
40885       {
40886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40887       };
40888     } catch (std::exception& e) {
40889       {
40890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40891       };
40892     } catch (...) {
40893       {
40894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40895       };
40896     }
40897   }
40898   jresult = (void *)result;
40899   return jresult;
40900 }
40901
40902
40903 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
40904   void * jresult ;
40905   unsigned int arg1 ;
40906   unsigned int arg2 ;
40907   Dali::Pixel::Format arg3 ;
40908   Dali::BufferImage result;
40909
40910   arg1 = (unsigned int)jarg1;
40911   arg2 = (unsigned int)jarg2;
40912   arg3 = (Dali::Pixel::Format)jarg3;
40913   {
40914     try {
40915       result = Dali::BufferImage::New(arg1,arg2,arg3);
40916     } catch (std::out_of_range& e) {
40917       {
40918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40919       };
40920     } catch (std::exception& e) {
40921       {
40922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40923       };
40924     } catch (...) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40927       };
40928     }
40929   }
40930   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40931   return jresult;
40932 }
40933
40934
40935 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
40936   void * jresult ;
40937   unsigned int arg1 ;
40938   unsigned int arg2 ;
40939   Dali::BufferImage result;
40940
40941   arg1 = (unsigned int)jarg1;
40942   arg2 = (unsigned int)jarg2;
40943   {
40944     try {
40945       result = Dali::BufferImage::New(arg1,arg2);
40946     } catch (std::out_of_range& e) {
40947       {
40948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40949       };
40950     } catch (std::exception& e) {
40951       {
40952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40953       };
40954     } catch (...) {
40955       {
40956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40957       };
40958     }
40959   }
40960   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40961   return jresult;
40962 }
40963
40964
40965 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
40966   void * jresult ;
40967   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40968   unsigned int arg2 ;
40969   unsigned int arg3 ;
40970   Dali::Pixel::Format arg4 ;
40971   unsigned int arg5 ;
40972   Dali::BufferImage result;
40973
40974   arg1 = jarg1;
40975   arg2 = (unsigned int)jarg2;
40976   arg3 = (unsigned int)jarg3;
40977   arg4 = (Dali::Pixel::Format)jarg4;
40978   arg5 = (unsigned int)jarg5;
40979   {
40980     try {
40981       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
40982     } catch (std::out_of_range& e) {
40983       {
40984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40985       };
40986     } catch (std::exception& e) {
40987       {
40988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40989       };
40990     } catch (...) {
40991       {
40992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40993       };
40994     }
40995   }
40996   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40997
40998
40999   return jresult;
41000 }
41001
41002
41003 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41004   void * jresult ;
41005   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41006   unsigned int arg2 ;
41007   unsigned int arg3 ;
41008   Dali::Pixel::Format arg4 ;
41009   Dali::BufferImage result;
41010
41011   arg1 = jarg1;
41012   arg2 = (unsigned int)jarg2;
41013   arg3 = (unsigned int)jarg3;
41014   arg4 = (Dali::Pixel::Format)jarg4;
41015   {
41016     try {
41017       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41018     } catch (std::out_of_range& e) {
41019       {
41020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41021       };
41022     } catch (std::exception& e) {
41023       {
41024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41025       };
41026     } catch (...) {
41027       {
41028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41029       };
41030     }
41031   }
41032   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41033
41034
41035   return jresult;
41036 }
41037
41038
41039 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41040   void * jresult ;
41041   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41042   unsigned int arg2 ;
41043   unsigned int arg3 ;
41044   Dali::BufferImage result;
41045
41046   arg1 = jarg1;
41047   arg2 = (unsigned int)jarg2;
41048   arg3 = (unsigned int)jarg3;
41049   {
41050     try {
41051       result = Dali::BufferImage::New(arg1,arg2,arg3);
41052     } catch (std::out_of_range& e) {
41053       {
41054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41055       };
41056     } catch (std::exception& e) {
41057       {
41058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41059       };
41060     } catch (...) {
41061       {
41062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41063       };
41064     }
41065   }
41066   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41067
41068
41069   return jresult;
41070 }
41071
41072
41073 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_DownCast(void * jarg1) {
41074   void * jresult ;
41075   Dali::BaseHandle arg1 ;
41076   Dali::BaseHandle *argp1 ;
41077   Dali::BufferImage result;
41078
41079   argp1 = (Dali::BaseHandle *)jarg1;
41080   if (!argp1) {
41081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41082     return 0;
41083   }
41084   arg1 = *argp1;
41085   {
41086     try {
41087       result = Dali::BufferImage::DownCast(arg1);
41088     } catch (std::out_of_range& e) {
41089       {
41090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41091       };
41092     } catch (std::exception& e) {
41093       {
41094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41095       };
41096     } catch (...) {
41097       {
41098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41099       };
41100     }
41101   }
41102   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41103   return jresult;
41104 }
41105
41106
41107 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BufferImage(void * jarg1) {
41108   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41109
41110   arg1 = (Dali::BufferImage *)jarg1;
41111   {
41112     try {
41113       delete arg1;
41114     } catch (std::out_of_range& e) {
41115       {
41116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41117       };
41118     } catch (std::exception& e) {
41119       {
41120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41121       };
41122     } catch (...) {
41123       {
41124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41125       };
41126     }
41127   }
41128 }
41129
41130
41131 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BufferImage__SWIG_1(void * jarg1) {
41132   void * jresult ;
41133   Dali::BufferImage *arg1 = 0 ;
41134   Dali::BufferImage *result = 0 ;
41135
41136   arg1 = (Dali::BufferImage *)jarg1;
41137   if (!arg1) {
41138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41139     return 0;
41140   }
41141   {
41142     try {
41143       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41144     } catch (std::out_of_range& e) {
41145       {
41146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41147       };
41148     } catch (std::exception& e) {
41149       {
41150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41151       };
41152     } catch (...) {
41153       {
41154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41155       };
41156     }
41157   }
41158   jresult = (void *)result;
41159   return jresult;
41160 }
41161
41162
41163 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_Assign(void * jarg1, void * jarg2) {
41164   void * jresult ;
41165   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41166   Dali::BufferImage *arg2 = 0 ;
41167   Dali::BufferImage *result = 0 ;
41168
41169   arg1 = (Dali::BufferImage *)jarg1;
41170   arg2 = (Dali::BufferImage *)jarg2;
41171   if (!arg2) {
41172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41173     return 0;
41174   }
41175   {
41176     try {
41177       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41178     } catch (std::out_of_range& e) {
41179       {
41180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41181       };
41182     } catch (std::exception& e) {
41183       {
41184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41185       };
41186     } catch (...) {
41187       {
41188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41189       };
41190     }
41191   }
41192   jresult = (void *)result;
41193   return jresult;
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_WHITE() {
41198   void * jresult ;
41199   Dali::BufferImage result;
41200
41201   {
41202     try {
41203       result = Dali::BufferImage::WHITE();
41204     } catch (std::out_of_range& e) {
41205       {
41206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41207       };
41208     } catch (std::exception& e) {
41209       {
41210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41211       };
41212     } catch (...) {
41213       {
41214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41215       };
41216     }
41217   }
41218   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_GetBuffer(void * jarg1) {
41224   void * jresult ;
41225   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41226   Dali::PixelBuffer *result = 0 ;
41227
41228   arg1 = (Dali::BufferImage *)jarg1;
41229   {
41230     try {
41231       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41239       };
41240     } catch (...) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41243       };
41244     }
41245   }
41246   jresult = (void *)result;
41247   return jresult;
41248 }
41249
41250
41251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_GetBufferSize(void * jarg1) {
41252   unsigned int jresult ;
41253   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41254   unsigned int result;
41255
41256   arg1 = (Dali::BufferImage *)jarg1;
41257   {
41258     try {
41259       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41260     } catch (std::out_of_range& e) {
41261       {
41262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41263       };
41264     } catch (std::exception& e) {
41265       {
41266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41267       };
41268     } catch (...) {
41269       {
41270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41271       };
41272     }
41273   }
41274   jresult = result;
41275   return jresult;
41276 }
41277
41278
41279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_GetBufferStride(void * jarg1) {
41280   unsigned int jresult ;
41281   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41282   unsigned int result;
41283
41284   arg1 = (Dali::BufferImage *)jarg1;
41285   {
41286     try {
41287       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41295       };
41296     } catch (...) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41299       };
41300     }
41301   }
41302   jresult = result;
41303   return jresult;
41304 }
41305
41306
41307 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BufferImage_GetPixelFormat(void * jarg1) {
41308   int jresult ;
41309   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41310   Dali::Pixel::Format result;
41311
41312   arg1 = (Dali::BufferImage *)jarg1;
41313   {
41314     try {
41315       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41316     } catch (std::out_of_range& e) {
41317       {
41318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41319       };
41320     } catch (std::exception& e) {
41321       {
41322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41323       };
41324     } catch (...) {
41325       {
41326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41327       };
41328     }
41329   }
41330   jresult = (int)result;
41331   return jresult;
41332 }
41333
41334
41335 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BufferImage_Update__SWIG_0(void * jarg1) {
41336   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41337
41338   arg1 = (Dali::BufferImage *)jarg1;
41339   {
41340     try {
41341       (arg1)->Update();
41342     } catch (std::out_of_range& e) {
41343       {
41344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41345       };
41346     } catch (std::exception& e) {
41347       {
41348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41349       };
41350     } catch (...) {
41351       {
41352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41353       };
41354     }
41355   }
41356 }
41357
41358
41359 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41360   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41361   Dali::RectArea arg2 ;
41362   Dali::RectArea *argp2 ;
41363
41364   arg1 = (Dali::BufferImage *)jarg1;
41365   argp2 = (Dali::RectArea *)jarg2;
41366   if (!argp2) {
41367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41368     return ;
41369   }
41370   arg2 = *argp2;
41371   {
41372     try {
41373       (arg1)->Update(arg2);
41374     } catch (std::out_of_range& e) {
41375       {
41376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41377       };
41378     } catch (std::exception& e) {
41379       {
41380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41381       };
41382     } catch (...) {
41383       {
41384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41385       };
41386     }
41387   }
41388 }
41389
41390
41391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_IsDataExternal(void * jarg1) {
41392   unsigned int jresult ;
41393   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41394   bool result;
41395
41396   arg1 = (Dali::BufferImage *)jarg1;
41397   {
41398     try {
41399       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41400     } catch (std::out_of_range& e) {
41401       {
41402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41403       };
41404     } catch (std::exception& e) {
41405       {
41406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41407       };
41408     } catch (...) {
41409       {
41410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41411       };
41412     }
41413   }
41414   jresult = result;
41415   return jresult;
41416 }
41417
41418
41419 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_EncodedBufferImage__SWIG_0() {
41420   void * jresult ;
41421   Dali::EncodedBufferImage *result = 0 ;
41422
41423   {
41424     try {
41425       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41426     } catch (std::out_of_range& e) {
41427       {
41428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (std::exception& e) {
41431       {
41432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41433       };
41434     } catch (...) {
41435       {
41436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41437       };
41438     }
41439   }
41440   jresult = (void *)result;
41441   return jresult;
41442 }
41443
41444
41445 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41446   void * jresult ;
41447   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41448   std::size_t arg2 ;
41449   Dali::EncodedBufferImage result;
41450
41451   arg1 = (uint8_t *)jarg1;
41452   arg2 = (std::size_t)jarg2;
41453   {
41454     try {
41455       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41456     } catch (std::out_of_range& e) {
41457       {
41458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41459       };
41460     } catch (std::exception& e) {
41461       {
41462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41463       };
41464     } catch (...) {
41465       {
41466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41467       };
41468     }
41469   }
41470   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41471   return jresult;
41472 }
41473
41474
41475 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41476   void * jresult ;
41477   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41478   std::size_t arg2 ;
41479   Dali::ImageDimensions arg3 ;
41480   Dali::FittingMode::Type arg4 ;
41481   Dali::SamplingMode::Type arg5 ;
41482   bool arg6 ;
41483   Dali::ImageDimensions *argp3 ;
41484   Dali::EncodedBufferImage result;
41485
41486   arg1 = (uint8_t *)jarg1;
41487   arg2 = (std::size_t)jarg2;
41488   argp3 = (Dali::ImageDimensions *)jarg3;
41489   if (!argp3) {
41490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41491     return 0;
41492   }
41493   arg3 = *argp3;
41494   arg4 = (Dali::FittingMode::Type)jarg4;
41495   arg5 = (Dali::SamplingMode::Type)jarg5;
41496   arg6 = jarg6 ? true : false;
41497   {
41498     try {
41499       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41500     } catch (std::out_of_range& e) {
41501       {
41502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (std::exception& e) {
41505       {
41506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41507       };
41508     } catch (...) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41511       };
41512     }
41513   }
41514   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41520   void * jresult ;
41521   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41522   std::size_t arg2 ;
41523   Dali::ImageDimensions arg3 ;
41524   Dali::FittingMode::Type arg4 ;
41525   Dali::SamplingMode::Type arg5 ;
41526   Dali::ImageDimensions *argp3 ;
41527   Dali::EncodedBufferImage result;
41528
41529   arg1 = (uint8_t *)jarg1;
41530   arg2 = (std::size_t)jarg2;
41531   argp3 = (Dali::ImageDimensions *)jarg3;
41532   if (!argp3) {
41533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41534     return 0;
41535   }
41536   arg3 = *argp3;
41537   arg4 = (Dali::FittingMode::Type)jarg4;
41538   arg5 = (Dali::SamplingMode::Type)jarg5;
41539   {
41540     try {
41541       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41542     } catch (std::out_of_range& e) {
41543       {
41544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41545       };
41546     } catch (std::exception& e) {
41547       {
41548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41549       };
41550     } catch (...) {
41551       {
41552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41553       };
41554     }
41555   }
41556   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41557   return jresult;
41558 }
41559
41560
41561 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_DownCast(void * jarg1) {
41562   void * jresult ;
41563   Dali::BaseHandle arg1 ;
41564   Dali::BaseHandle *argp1 ;
41565   Dali::EncodedBufferImage result;
41566
41567   argp1 = (Dali::BaseHandle *)jarg1;
41568   if (!argp1) {
41569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41570     return 0;
41571   }
41572   arg1 = *argp1;
41573   {
41574     try {
41575       result = Dali::EncodedBufferImage::DownCast(arg1);
41576     } catch (std::out_of_range& e) {
41577       {
41578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41579       };
41580     } catch (std::exception& e) {
41581       {
41582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41583       };
41584     } catch (...) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41587       };
41588     }
41589   }
41590   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41591   return jresult;
41592 }
41593
41594
41595 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_EncodedBufferImage(void * jarg1) {
41596   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41597
41598   arg1 = (Dali::EncodedBufferImage *)jarg1;
41599   {
41600     try {
41601       delete arg1;
41602     } catch (std::out_of_range& e) {
41603       {
41604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41605       };
41606     } catch (std::exception& e) {
41607       {
41608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41609       };
41610     } catch (...) {
41611       {
41612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41613       };
41614     }
41615   }
41616 }
41617
41618
41619 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41620   void * jresult ;
41621   Dali::EncodedBufferImage *arg1 = 0 ;
41622   Dali::EncodedBufferImage *result = 0 ;
41623
41624   arg1 = (Dali::EncodedBufferImage *)jarg1;
41625   if (!arg1) {
41626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41627     return 0;
41628   }
41629   {
41630     try {
41631       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41632     } catch (std::out_of_range& e) {
41633       {
41634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41635       };
41636     } catch (std::exception& e) {
41637       {
41638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41639       };
41640     } catch (...) {
41641       {
41642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41643       };
41644     }
41645   }
41646   jresult = (void *)result;
41647   return jresult;
41648 }
41649
41650
41651 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41652   void * jresult ;
41653   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41654   Dali::EncodedBufferImage *arg2 = 0 ;
41655   Dali::EncodedBufferImage *result = 0 ;
41656
41657   arg1 = (Dali::EncodedBufferImage *)jarg1;
41658   arg2 = (Dali::EncodedBufferImage *)jarg2;
41659   if (!arg2) {
41660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41661     return 0;
41662   }
41663   {
41664     try {
41665       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41666     } catch (std::out_of_range& e) {
41667       {
41668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (std::exception& e) {
41671       {
41672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41673       };
41674     } catch (...) {
41675       {
41676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41677       };
41678     }
41679   }
41680   jresult = (void *)result;
41681   return jresult;
41682 }
41683
41684
41685 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NativeImage__SWIG_0() {
41686   void * jresult ;
41687   Dali::NativeImage *result = 0 ;
41688
41689   {
41690     try {
41691       result = (Dali::NativeImage *)new Dali::NativeImage();
41692     } catch (std::out_of_range& e) {
41693       {
41694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41695       };
41696     } catch (std::exception& e) {
41697       {
41698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41699       };
41700     } catch (...) {
41701       {
41702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41703       };
41704     }
41705   }
41706   jresult = (void *)result;
41707   return jresult;
41708 }
41709
41710
41711 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_NativeImage(void * jarg1) {
41712   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41713
41714   arg1 = (Dali::NativeImage *)jarg1;
41715   {
41716     try {
41717       delete arg1;
41718     } catch (std::out_of_range& e) {
41719       {
41720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41721       };
41722     } catch (std::exception& e) {
41723       {
41724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41725       };
41726     } catch (...) {
41727       {
41728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41729       };
41730     }
41731   }
41732 }
41733
41734
41735 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NativeImage__SWIG_1(void * jarg1) {
41736   void * jresult ;
41737   Dali::NativeImage *arg1 = 0 ;
41738   Dali::NativeImage *result = 0 ;
41739
41740   arg1 = (Dali::NativeImage *)jarg1;
41741   if (!arg1) {
41742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41743     return 0;
41744   }
41745   {
41746     try {
41747       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41748     } catch (std::out_of_range& e) {
41749       {
41750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (std::exception& e) {
41753       {
41754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41755       };
41756     } catch (...) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41759       };
41760     }
41761   }
41762   jresult = (void *)result;
41763   return jresult;
41764 }
41765
41766
41767 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_Assign(void * jarg1, void * jarg2) {
41768   void * jresult ;
41769   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41770   Dali::NativeImage *arg2 = 0 ;
41771   Dali::NativeImage *result = 0 ;
41772
41773   arg1 = (Dali::NativeImage *)jarg1;
41774   arg2 = (Dali::NativeImage *)jarg2;
41775   if (!arg2) {
41776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41777     return 0;
41778   }
41779   {
41780     try {
41781       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41782     } catch (std::out_of_range& e) {
41783       {
41784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41785       };
41786     } catch (std::exception& e) {
41787       {
41788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (...) {
41791       {
41792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41793       };
41794     }
41795   }
41796   jresult = (void *)result;
41797   return jresult;
41798 }
41799
41800
41801 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImage_CreateGlTexture(void * jarg1) {
41802   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41803
41804   arg1 = (Dali::NativeImage *)jarg1;
41805   {
41806     try {
41807       (arg1)->CreateGlTexture();
41808     } catch (std::out_of_range& e) {
41809       {
41810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41811       };
41812     } catch (std::exception& e) {
41813       {
41814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41815       };
41816     } catch (...) {
41817       {
41818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41819       };
41820     }
41821   }
41822 }
41823
41824
41825 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_New(void * jarg1) {
41826   void * jresult ;
41827   NativeImageInterface *arg1 = 0 ;
41828   Dali::NativeImage result;
41829
41830   arg1 = (NativeImageInterface *)jarg1;
41831   if (!arg1) {
41832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41833     return 0;
41834   }
41835   {
41836     try {
41837       result = Dali::NativeImage::New(*arg1);
41838     } catch (std::out_of_range& e) {
41839       {
41840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41841       };
41842     } catch (std::exception& e) {
41843       {
41844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41845       };
41846     } catch (...) {
41847       {
41848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41849       };
41850     }
41851   }
41852   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41853   return jresult;
41854 }
41855
41856
41857 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_DownCast(void * jarg1) {
41858   void * jresult ;
41859   Dali::BaseHandle arg1 ;
41860   Dali::BaseHandle *argp1 ;
41861   Dali::NativeImage result;
41862
41863   argp1 = (Dali::BaseHandle *)jarg1;
41864   if (!argp1) {
41865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41866     return 0;
41867   }
41868   arg1 = *argp1;
41869   {
41870     try {
41871       result = Dali::NativeImage::DownCast(arg1);
41872     } catch (std::out_of_range& e) {
41873       {
41874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41875       };
41876     } catch (std::exception& e) {
41877       {
41878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41879       };
41880     } catch (...) {
41881       {
41882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41883       };
41884     }
41885   }
41886   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41887   return jresult;
41888 }
41889
41890
41891 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
41892   char * jresult ;
41893   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41894   char *result = 0 ;
41895
41896   arg1 = (Dali::NativeImage *)jarg1;
41897   {
41898     try {
41899       result = (char *)(arg1)->GetCustomFragmentPreFix();
41900     } catch (std::out_of_range& e) {
41901       {
41902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (std::exception& e) {
41905       {
41906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (...) {
41909       {
41910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41911       };
41912     }
41913   }
41914   jresult = SWIG_csharp_string_callback((const char *)result);
41915   return jresult;
41916 }
41917
41918
41919 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_NativeImage_GetCustomSamplerTypename(void * jarg1) {
41920   char * jresult ;
41921   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41922   char *result = 0 ;
41923
41924   arg1 = (Dali::NativeImage *)jarg1;
41925   {
41926     try {
41927       result = (char *)(arg1)->GetCustomSamplerTypename();
41928     } catch (std::out_of_range& e) {
41929       {
41930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41931       };
41932     } catch (std::exception& e) {
41933       {
41934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41935       };
41936     } catch (...) {
41937       {
41938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41939       };
41940     }
41941   }
41942   jresult = SWIG_csharp_string_callback((const char *)result);
41943   return jresult;
41944 }
41945
41946
41947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GlExtensionCreate(void * jarg1) {
41948   unsigned int jresult ;
41949   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41950   bool result;
41951
41952   arg1 = (Dali::NativeImageInterface *)jarg1;
41953   {
41954     try {
41955       result = (bool)(arg1)->GlExtensionCreate();
41956     } catch (std::out_of_range& e) {
41957       {
41958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41959       };
41960     } catch (std::exception& e) {
41961       {
41962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41963       };
41964     } catch (...) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41967       };
41968     }
41969   }
41970   jresult = result;
41971   return jresult;
41972 }
41973
41974
41975 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
41976   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41977
41978   arg1 = (Dali::NativeImageInterface *)jarg1;
41979   {
41980     try {
41981       (arg1)->GlExtensionDestroy();
41982     } catch (std::out_of_range& e) {
41983       {
41984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41985       };
41986     } catch (std::exception& e) {
41987       {
41988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41989       };
41990     } catch (...) {
41991       {
41992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41993       };
41994     }
41995   }
41996 }
41997
41998
41999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_TargetTexture(void * jarg1) {
42000   unsigned int jresult ;
42001   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42002   unsigned int result;
42003
42004   arg1 = (Dali::NativeImageInterface *)jarg1;
42005   {
42006     try {
42007       result = (unsigned int)(arg1)->TargetTexture();
42008     } catch (std::out_of_range& e) {
42009       {
42010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42011       };
42012     } catch (std::exception& e) {
42013       {
42014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42015       };
42016     } catch (...) {
42017       {
42018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42019       };
42020     }
42021   }
42022   jresult = result;
42023   return jresult;
42024 }
42025
42026
42027 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImageInterface_PrepareTexture(void * jarg1) {
42028   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42029
42030   arg1 = (Dali::NativeImageInterface *)jarg1;
42031   {
42032     try {
42033       (arg1)->PrepareTexture();
42034     } catch (std::out_of_range& e) {
42035       {
42036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42037       };
42038     } catch (std::exception& e) {
42039       {
42040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42041       };
42042     } catch (...) {
42043       {
42044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42045       };
42046     }
42047   }
42048 }
42049
42050
42051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GetWidth(void * jarg1) {
42052   unsigned int jresult ;
42053   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42054   unsigned int result;
42055
42056   arg1 = (Dali::NativeImageInterface *)jarg1;
42057   {
42058     try {
42059       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42060     } catch (std::out_of_range& e) {
42061       {
42062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (std::exception& e) {
42065       {
42066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42067       };
42068     } catch (...) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42071       };
42072     }
42073   }
42074   jresult = result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GetHeight(void * jarg1) {
42080   unsigned int jresult ;
42081   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42082   unsigned int result;
42083
42084   arg1 = (Dali::NativeImageInterface *)jarg1;
42085   {
42086     try {
42087       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42088     } catch (std::out_of_range& e) {
42089       {
42090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42091       };
42092     } catch (std::exception& e) {
42093       {
42094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42095       };
42096     } catch (...) {
42097       {
42098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42099       };
42100     }
42101   }
42102   jresult = result;
42103   return jresult;
42104 }
42105
42106
42107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_RequiresBlending(void * jarg1) {
42108   unsigned int jresult ;
42109   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42110   bool result;
42111
42112   arg1 = (Dali::NativeImageInterface *)jarg1;
42113   {
42114     try {
42115       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42116     } catch (std::out_of_range& e) {
42117       {
42118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42119       };
42120     } catch (std::exception& e) {
42121       {
42122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42123       };
42124     } catch (...) {
42125       {
42126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42127       };
42128     }
42129   }
42130   jresult = result;
42131   return jresult;
42132 }
42133
42134
42135 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_GetImageSize(char * jarg1) {
42136   void * jresult ;
42137   std::string *arg1 = 0 ;
42138   Dali::ImageDimensions result;
42139
42140   if (!jarg1) {
42141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42142     return 0;
42143   }
42144   std::string arg1_str(jarg1);
42145   arg1 = &arg1_str;
42146   {
42147     try {
42148       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42149     } catch (std::out_of_range& e) {
42150       {
42151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42152       };
42153     } catch (std::exception& e) {
42154       {
42155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42156       };
42157     } catch (...) {
42158       {
42159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42160       };
42161     }
42162   }
42163   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42164
42165   //argout typemap for const std::string&
42166
42167   return jresult;
42168 }
42169
42170
42171 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImage__SWIG_0() {
42172   void * jresult ;
42173   Dali::ResourceImage *result = 0 ;
42174
42175   {
42176     try {
42177       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42178     } catch (std::out_of_range& e) {
42179       {
42180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42181       };
42182     } catch (std::exception& e) {
42183       {
42184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42185       };
42186     } catch (...) {
42187       {
42188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42189       };
42190     }
42191   }
42192   jresult = (void *)result;
42193   return jresult;
42194 }
42195
42196
42197 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ResourceImage(void * jarg1) {
42198   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42199
42200   arg1 = (Dali::ResourceImage *)jarg1;
42201   {
42202     try {
42203       delete arg1;
42204     } catch (std::out_of_range& e) {
42205       {
42206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42207       };
42208     } catch (std::exception& e) {
42209       {
42210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42211       };
42212     } catch (...) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42215       };
42216     }
42217   }
42218 }
42219
42220
42221 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImage__SWIG_1(void * jarg1) {
42222   void * jresult ;
42223   Dali::ResourceImage *arg1 = 0 ;
42224   Dali::ResourceImage *result = 0 ;
42225
42226   arg1 = (Dali::ResourceImage *)jarg1;
42227   if (!arg1) {
42228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42229     return 0;
42230   }
42231   {
42232     try {
42233       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42234     } catch (std::out_of_range& e) {
42235       {
42236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (std::exception& e) {
42239       {
42240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42241       };
42242     } catch (...) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42245       };
42246     }
42247   }
42248   jresult = (void *)result;
42249   return jresult;
42250 }
42251
42252
42253 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_Assign(void * jarg1, void * jarg2) {
42254   void * jresult ;
42255   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42256   Dali::ResourceImage *arg2 = 0 ;
42257   Dali::ResourceImage *result = 0 ;
42258
42259   arg1 = (Dali::ResourceImage *)jarg1;
42260   arg2 = (Dali::ResourceImage *)jarg2;
42261   if (!arg2) {
42262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42263     return 0;
42264   }
42265   {
42266     try {
42267       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42268     } catch (std::out_of_range& e) {
42269       {
42270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42271       };
42272     } catch (std::exception& e) {
42273       {
42274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42275       };
42276     } catch (...) {
42277       {
42278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42279       };
42280     }
42281   }
42282   jresult = (void *)result;
42283   return jresult;
42284 }
42285
42286
42287 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42288   void * jresult ;
42289   std::string *arg1 = 0 ;
42290   bool arg2 ;
42291   Dali::ResourceImage result;
42292
42293   if (!jarg1) {
42294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42295     return 0;
42296   }
42297   std::string arg1_str(jarg1);
42298   arg1 = &arg1_str;
42299   arg2 = jarg2 ? true : false;
42300   {
42301     try {
42302       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42303     } catch (std::out_of_range& e) {
42304       {
42305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42306       };
42307     } catch (std::exception& e) {
42308       {
42309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42310       };
42311     } catch (...) {
42312       {
42313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42314       };
42315     }
42316   }
42317   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42318
42319   //argout typemap for const std::string&
42320
42321   return jresult;
42322 }
42323
42324
42325 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_1(char * jarg1) {
42326   void * jresult ;
42327   std::string *arg1 = 0 ;
42328   Dali::ResourceImage result;
42329
42330   if (!jarg1) {
42331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42332     return 0;
42333   }
42334   std::string arg1_str(jarg1);
42335   arg1 = &arg1_str;
42336   {
42337     try {
42338       result = Dali::ResourceImage::New((std::string const &)*arg1);
42339     } catch (std::out_of_range& e) {
42340       {
42341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42342       };
42343     } catch (std::exception& e) {
42344       {
42345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42350       };
42351     }
42352   }
42353   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42354
42355   //argout typemap for const std::string&
42356
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42362   void * jresult ;
42363   std::string *arg1 = 0 ;
42364   Dali::ImageDimensions arg2 ;
42365   Dali::FittingMode::Type arg3 ;
42366   Dali::SamplingMode::Type arg4 ;
42367   bool arg5 ;
42368   Dali::ImageDimensions *argp2 ;
42369   Dali::ResourceImage result;
42370
42371   if (!jarg1) {
42372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42373     return 0;
42374   }
42375   std::string arg1_str(jarg1);
42376   arg1 = &arg1_str;
42377   argp2 = (Dali::ImageDimensions *)jarg2;
42378   if (!argp2) {
42379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42380     return 0;
42381   }
42382   arg2 = *argp2;
42383   arg3 = (Dali::FittingMode::Type)jarg3;
42384   arg4 = (Dali::SamplingMode::Type)jarg4;
42385   arg5 = jarg5 ? true : false;
42386   {
42387     try {
42388       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42389     } catch (std::out_of_range& e) {
42390       {
42391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42392       };
42393     } catch (std::exception& e) {
42394       {
42395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (...) {
42398       {
42399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42400       };
42401     }
42402   }
42403   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42404
42405   //argout typemap for const std::string&
42406
42407   return jresult;
42408 }
42409
42410
42411 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42412   void * jresult ;
42413   std::string *arg1 = 0 ;
42414   Dali::ImageDimensions arg2 ;
42415   Dali::FittingMode::Type arg3 ;
42416   Dali::SamplingMode::Type arg4 ;
42417   Dali::ImageDimensions *argp2 ;
42418   Dali::ResourceImage result;
42419
42420   if (!jarg1) {
42421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42422     return 0;
42423   }
42424   std::string arg1_str(jarg1);
42425   arg1 = &arg1_str;
42426   argp2 = (Dali::ImageDimensions *)jarg2;
42427   if (!argp2) {
42428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42429     return 0;
42430   }
42431   arg2 = *argp2;
42432   arg3 = (Dali::FittingMode::Type)jarg3;
42433   arg4 = (Dali::SamplingMode::Type)jarg4;
42434   {
42435     try {
42436       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42437     } catch (std::out_of_range& e) {
42438       {
42439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42440       };
42441     } catch (std::exception& e) {
42442       {
42443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42444       };
42445     } catch (...) {
42446       {
42447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42448       };
42449     }
42450   }
42451   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42452
42453   //argout typemap for const std::string&
42454
42455   return jresult;
42456 }
42457
42458
42459 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42460   void * jresult ;
42461   std::string *arg1 = 0 ;
42462   Dali::ImageDimensions arg2 ;
42463   Dali::FittingMode::Type arg3 ;
42464   Dali::ImageDimensions *argp2 ;
42465   Dali::ResourceImage result;
42466
42467   if (!jarg1) {
42468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42469     return 0;
42470   }
42471   std::string arg1_str(jarg1);
42472   arg1 = &arg1_str;
42473   argp2 = (Dali::ImageDimensions *)jarg2;
42474   if (!argp2) {
42475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42476     return 0;
42477   }
42478   arg2 = *argp2;
42479   arg3 = (Dali::FittingMode::Type)jarg3;
42480   {
42481     try {
42482       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42483     } catch (std::out_of_range& e) {
42484       {
42485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42486       };
42487     } catch (std::exception& e) {
42488       {
42489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (...) {
42492       {
42493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42494       };
42495     }
42496   }
42497   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42498
42499   //argout typemap for const std::string&
42500
42501   return jresult;
42502 }
42503
42504
42505 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42506   void * jresult ;
42507   std::string *arg1 = 0 ;
42508   Dali::ImageDimensions arg2 ;
42509   Dali::ImageDimensions *argp2 ;
42510   Dali::ResourceImage result;
42511
42512   if (!jarg1) {
42513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42514     return 0;
42515   }
42516   std::string arg1_str(jarg1);
42517   arg1 = &arg1_str;
42518   argp2 = (Dali::ImageDimensions *)jarg2;
42519   if (!argp2) {
42520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42521     return 0;
42522   }
42523   arg2 = *argp2;
42524   {
42525     try {
42526       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42527     } catch (std::out_of_range& e) {
42528       {
42529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (std::exception& e) {
42532       {
42533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (...) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42538       };
42539     }
42540   }
42541   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42542
42543   //argout typemap for const std::string&
42544
42545   return jresult;
42546 }
42547
42548
42549 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_DownCast(void * jarg1) {
42550   void * jresult ;
42551   Dali::BaseHandle arg1 ;
42552   Dali::BaseHandle *argp1 ;
42553   Dali::ResourceImage result;
42554
42555   argp1 = (Dali::BaseHandle *)jarg1;
42556   if (!argp1) {
42557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42558     return 0;
42559   }
42560   arg1 = *argp1;
42561   {
42562     try {
42563       result = Dali::ResourceImage::DownCast(arg1);
42564     } catch (std::out_of_range& e) {
42565       {
42566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (std::exception& e) {
42569       {
42570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42579   return jresult;
42580 }
42581
42582
42583 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ResourceImage_GetLoadingState(void * jarg1) {
42584   int jresult ;
42585   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42586   Dali::LoadingState result;
42587
42588   arg1 = (Dali::ResourceImage *)jarg1;
42589   {
42590     try {
42591       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42592     } catch (std::out_of_range& e) {
42593       {
42594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (std::exception& e) {
42597       {
42598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42599       };
42600     } catch (...) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42603       };
42604     }
42605   }
42606   jresult = (int)result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_ResourceImage_GetUrl(void * jarg1) {
42612   char * jresult ;
42613   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42614   std::string result;
42615
42616   arg1 = (Dali::ResourceImage *)jarg1;
42617   {
42618     try {
42619       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (...) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42631       };
42632     }
42633   }
42634   jresult = SWIG_csharp_string_callback((&result)->c_str());
42635   return jresult;
42636 }
42637
42638
42639 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImage_Reload(void * jarg1) {
42640   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42641
42642   arg1 = (Dali::ResourceImage *)jarg1;
42643   {
42644     try {
42645       (arg1)->Reload();
42646     } catch (std::out_of_range& e) {
42647       {
42648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42649       };
42650     } catch (std::exception& e) {
42651       {
42652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42653       };
42654     } catch (...) {
42655       {
42656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42657       };
42658     }
42659   }
42660 }
42661
42662
42663 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42664   void * jresult ;
42665   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42666   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42667
42668   arg1 = (Dali::ResourceImage *)jarg1;
42669   {
42670     try {
42671       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42672     } catch (std::out_of_range& e) {
42673       {
42674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42675       };
42676     } catch (std::exception& e) {
42677       {
42678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42679       };
42680     } catch (...) {
42681       {
42682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42683       };
42684     }
42685   }
42686   jresult = (void *)result;
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBufferImage__SWIG_0() {
42692   void * jresult ;
42693   Dali::FrameBufferImage *result = 0 ;
42694
42695   {
42696     try {
42697       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42698     } catch (std::out_of_range& e) {
42699       {
42700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42701       };
42702     } catch (std::exception& e) {
42703       {
42704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42705       };
42706     } catch (...) {
42707       {
42708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42709       };
42710     }
42711   }
42712   jresult = (void *)result;
42713   return jresult;
42714 }
42715
42716
42717 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42718   void * jresult ;
42719   unsigned int arg1 ;
42720   unsigned int arg2 ;
42721   Dali::Pixel::Format arg3 ;
42722   Dali::RenderBuffer::Format arg4 ;
42723   Dali::FrameBufferImage result;
42724
42725   arg1 = (unsigned int)jarg1;
42726   arg2 = (unsigned int)jarg2;
42727   arg3 = (Dali::Pixel::Format)jarg3;
42728   arg4 = (Dali::RenderBuffer::Format)jarg4;
42729   {
42730     try {
42731       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42732     } catch (std::out_of_range& e) {
42733       {
42734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42735       };
42736     } catch (std::exception& e) {
42737       {
42738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42739       };
42740     } catch (...) {
42741       {
42742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42743       };
42744     }
42745   }
42746   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42747   return jresult;
42748 }
42749
42750
42751 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42752   void * jresult ;
42753   unsigned int arg1 ;
42754   unsigned int arg2 ;
42755   Dali::Pixel::Format arg3 ;
42756   Dali::FrameBufferImage result;
42757
42758   arg1 = (unsigned int)jarg1;
42759   arg2 = (unsigned int)jarg2;
42760   arg3 = (Dali::Pixel::Format)jarg3;
42761   {
42762     try {
42763       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42764     } catch (std::out_of_range& e) {
42765       {
42766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42767       };
42768     } catch (std::exception& e) {
42769       {
42770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42771       };
42772     } catch (...) {
42773       {
42774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42775       };
42776     }
42777   }
42778   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42779   return jresult;
42780 }
42781
42782
42783 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42784   void * jresult ;
42785   unsigned int arg1 ;
42786   unsigned int arg2 ;
42787   Dali::FrameBufferImage result;
42788
42789   arg1 = (unsigned int)jarg1;
42790   arg2 = (unsigned int)jarg2;
42791   {
42792     try {
42793       result = Dali::FrameBufferImage::New(arg1,arg2);
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::FrameBufferImage((const Dali::FrameBufferImage &)result);
42809   return jresult;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42814   void * jresult ;
42815   unsigned int arg1 ;
42816   Dali::FrameBufferImage result;
42817
42818   arg1 = (unsigned int)jarg1;
42819   {
42820     try {
42821       result = Dali::FrameBufferImage::New(arg1);
42822     } catch (std::out_of_range& e) {
42823       {
42824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42825       };
42826     } catch (std::exception& e) {
42827       {
42828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (...) {
42831       {
42832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42833       };
42834     }
42835   }
42836   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42837   return jresult;
42838 }
42839
42840
42841 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_4() {
42842   void * jresult ;
42843   Dali::FrameBufferImage result;
42844
42845   {
42846     try {
42847       result = Dali::FrameBufferImage::New();
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42863   return jresult;
42864 }
42865
42866
42867 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_5(void * jarg1) {
42868   void * jresult ;
42869   Dali::NativeImageInterface *arg1 = 0 ;
42870   Dali::FrameBufferImage result;
42871
42872   arg1 = (Dali::NativeImageInterface *)jarg1;
42873   if (!arg1) {
42874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
42875     return 0;
42876   }
42877   {
42878     try {
42879       result = Dali::FrameBufferImage::New(*arg1);
42880     } catch (std::out_of_range& e) {
42881       {
42882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42883       };
42884     } catch (std::exception& e) {
42885       {
42886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (...) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42891       };
42892     }
42893   }
42894   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42895   return jresult;
42896 }
42897
42898
42899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_DownCast(void * jarg1) {
42900   void * jresult ;
42901   Dali::BaseHandle arg1 ;
42902   Dali::BaseHandle *argp1 ;
42903   Dali::FrameBufferImage result;
42904
42905   argp1 = (Dali::BaseHandle *)jarg1;
42906   if (!argp1) {
42907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42908     return 0;
42909   }
42910   arg1 = *argp1;
42911   {
42912     try {
42913       result = Dali::FrameBufferImage::DownCast(arg1);
42914     } catch (std::out_of_range& e) {
42915       {
42916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42917       };
42918     } catch (std::exception& e) {
42919       {
42920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42921       };
42922     } catch (...) {
42923       {
42924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42925       };
42926     }
42927   }
42928   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42929   return jresult;
42930 }
42931
42932
42933 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBufferImage(void * jarg1) {
42934   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42935
42936   arg1 = (Dali::FrameBufferImage *)jarg1;
42937   {
42938     try {
42939       delete arg1;
42940     } catch (std::out_of_range& e) {
42941       {
42942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42943       };
42944     } catch (std::exception& e) {
42945       {
42946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42951       };
42952     }
42953   }
42954 }
42955
42956
42957 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBufferImage__SWIG_1(void * jarg1) {
42958   void * jresult ;
42959   Dali::FrameBufferImage *arg1 = 0 ;
42960   Dali::FrameBufferImage *result = 0 ;
42961
42962   arg1 = (Dali::FrameBufferImage *)jarg1;
42963   if (!arg1) {
42964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42965     return 0;
42966   }
42967   {
42968     try {
42969       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
42970     } catch (std::out_of_range& e) {
42971       {
42972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42973       };
42974     } catch (std::exception& e) {
42975       {
42976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (...) {
42979       {
42980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42981       };
42982     }
42983   }
42984   jresult = (void *)result;
42985   return jresult;
42986 }
42987
42988
42989 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
42990   void * jresult ;
42991   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42992   Dali::FrameBufferImage *arg2 = 0 ;
42993   Dali::FrameBufferImage *result = 0 ;
42994
42995   arg1 = (Dali::FrameBufferImage *)jarg1;
42996   arg2 = (Dali::FrameBufferImage *)jarg2;
42997   if (!arg2) {
42998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42999     return 0;
43000   }
43001   {
43002     try {
43003       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43004     } catch (std::out_of_range& e) {
43005       {
43006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43007       };
43008     } catch (std::exception& e) {
43009       {
43010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43011       };
43012     } catch (...) {
43013       {
43014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43015       };
43016     }
43017   }
43018   jresult = (void *)result;
43019   return jresult;
43020 }
43021
43022
43023 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NinePatchImage__SWIG_0() {
43024   void * jresult ;
43025   Dali::NinePatchImage *result = 0 ;
43026
43027   {
43028     try {
43029       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43037       };
43038     } catch (...) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43041       };
43042     }
43043   }
43044   jresult = (void *)result;
43045   return jresult;
43046 }
43047
43048
43049 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_New(char * jarg1) {
43050   void * jresult ;
43051   std::string *arg1 = 0 ;
43052   Dali::NinePatchImage result;
43053
43054   if (!jarg1) {
43055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43056     return 0;
43057   }
43058   std::string arg1_str(jarg1);
43059   arg1 = &arg1_str;
43060   {
43061     try {
43062       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43063     } catch (std::out_of_range& e) {
43064       {
43065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43066       };
43067     } catch (std::exception& e) {
43068       {
43069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43070       };
43071     } catch (...) {
43072       {
43073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43074       };
43075     }
43076   }
43077   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43078
43079   //argout typemap for const std::string&
43080
43081   return jresult;
43082 }
43083
43084
43085 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_DownCast(void * jarg1) {
43086   void * jresult ;
43087   Dali::BaseHandle arg1 ;
43088   Dali::BaseHandle *argp1 ;
43089   Dali::NinePatchImage result;
43090
43091   argp1 = (Dali::BaseHandle *)jarg1;
43092   if (!argp1) {
43093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43094     return 0;
43095   }
43096   arg1 = *argp1;
43097   {
43098     try {
43099       result = Dali::NinePatchImage::DownCast(arg1);
43100     } catch (std::out_of_range& e) {
43101       {
43102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43103       };
43104     } catch (std::exception& e) {
43105       {
43106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43107       };
43108     } catch (...) {
43109       {
43110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43111       };
43112     }
43113   }
43114   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43115   return jresult;
43116 }
43117
43118
43119 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_NinePatchImage(void * jarg1) {
43120   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43121
43122   arg1 = (Dali::NinePatchImage *)jarg1;
43123   {
43124     try {
43125       delete arg1;
43126     } catch (std::out_of_range& e) {
43127       {
43128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43129       };
43130     } catch (std::exception& e) {
43131       {
43132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43133       };
43134     } catch (...) {
43135       {
43136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43137       };
43138     }
43139   }
43140 }
43141
43142
43143 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NinePatchImage__SWIG_1(void * jarg1) {
43144   void * jresult ;
43145   Dali::NinePatchImage *arg1 = 0 ;
43146   Dali::NinePatchImage *result = 0 ;
43147
43148   arg1 = (Dali::NinePatchImage *)jarg1;
43149   if (!arg1) {
43150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43151     return 0;
43152   }
43153   {
43154     try {
43155       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43156     } catch (std::out_of_range& e) {
43157       {
43158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43159       };
43160     } catch (std::exception& e) {
43161       {
43162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43163       };
43164     } catch (...) {
43165       {
43166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43167       };
43168     }
43169   }
43170   jresult = (void *)result;
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43176   void * jresult ;
43177   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43178   Dali::NinePatchImage *arg2 = 0 ;
43179   Dali::NinePatchImage *result = 0 ;
43180
43181   arg1 = (Dali::NinePatchImage *)jarg1;
43182   arg2 = (Dali::NinePatchImage *)jarg2;
43183   if (!arg2) {
43184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43185     return 0;
43186   }
43187   {
43188     try {
43189       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43190     } catch (std::out_of_range& e) {
43191       {
43192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43193       };
43194     } catch (std::exception& e) {
43195       {
43196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43201       };
43202     }
43203   }
43204   jresult = (void *)result;
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchBorders(void * jarg1) {
43210   void * jresult ;
43211   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43212   Dali::Vector4 result;
43213
43214   arg1 = (Dali::NinePatchImage *)jarg1;
43215   {
43216     try {
43217       result = (arg1)->GetStretchBorders();
43218     } catch (std::out_of_range& e) {
43219       {
43220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43221       };
43222     } catch (std::exception& e) {
43223       {
43224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43225       };
43226     } catch (...) {
43227       {
43228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43229       };
43230     }
43231   }
43232   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43233   return jresult;
43234 }
43235
43236
43237 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43238   void * jresult ;
43239   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43240   Dali::NinePatchImage::StretchRanges *result = 0 ;
43241
43242   arg1 = (Dali::NinePatchImage *)jarg1;
43243   {
43244     try {
43245       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43246     } catch (std::out_of_range& e) {
43247       {
43248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43249       };
43250     } catch (std::exception& e) {
43251       {
43252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43253       };
43254     } catch (...) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43257       };
43258     }
43259   }
43260   jresult = (void *)result;
43261   return jresult;
43262 }
43263
43264
43265 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43266   void * jresult ;
43267   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43268   Dali::NinePatchImage::StretchRanges *result = 0 ;
43269
43270   arg1 = (Dali::NinePatchImage *)jarg1;
43271   {
43272     try {
43273       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43274     } catch (std::out_of_range& e) {
43275       {
43276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43277       };
43278     } catch (std::exception& e) {
43279       {
43280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43281       };
43282     } catch (...) {
43283       {
43284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43285       };
43286     }
43287   }
43288   jresult = (void *)result;
43289   return jresult;
43290 }
43291
43292
43293 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetChildRectangle(void * jarg1) {
43294   void * jresult ;
43295   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43296   Dali::Rect< int > result;
43297
43298   arg1 = (Dali::NinePatchImage *)jarg1;
43299   {
43300     try {
43301       result = (arg1)->GetChildRectangle();
43302     } catch (std::out_of_range& e) {
43303       {
43304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43305       };
43306     } catch (std::exception& e) {
43307       {
43308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43309       };
43310     } catch (...) {
43311       {
43312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43313       };
43314     }
43315   }
43316   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43317   return jresult;
43318 }
43319
43320
43321 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43322   void * jresult ;
43323   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43324   Dali::BufferImage result;
43325
43326   arg1 = (Dali::NinePatchImage *)jarg1;
43327   {
43328     try {
43329       result = (arg1)->CreateCroppedBufferImage();
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (...) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43341       };
43342     }
43343   }
43344   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43345   return jresult;
43346 }
43347
43348
43349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43350   unsigned int jresult ;
43351   std::string *arg1 = 0 ;
43352   bool result;
43353
43354   if (!jarg1) {
43355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43356     return 0;
43357   }
43358   std::string arg1_str(jarg1);
43359   arg1 = &arg1_str;
43360   {
43361     try {
43362       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43363     } catch (std::out_of_range& e) {
43364       {
43365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43366       };
43367     } catch (std::exception& e) {
43368       {
43369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (...) {
43372       {
43373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43374       };
43375     }
43376   }
43377   jresult = result;
43378
43379   //argout typemap for const std::string&
43380
43381   return jresult;
43382 }
43383
43384
43385 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TYPE_get() {
43386   int jresult ;
43387   int result;
43388
43389   result = (int)Dali::CameraActor::Property::TYPE;
43390   jresult = (int)result;
43391   return jresult;
43392 }
43393
43394
43395 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_PROJECTION_MODE_get() {
43396   int jresult ;
43397   int result;
43398
43399   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43400   jresult = (int)result;
43401   return jresult;
43402 }
43403
43404
43405 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_FIELD_OF_VIEW_get() {
43406   int jresult ;
43407   int result;
43408
43409   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43410   jresult = (int)result;
43411   return jresult;
43412 }
43413
43414
43415 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_ASPECT_RATIO_get() {
43416   int jresult ;
43417   int result;
43418
43419   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43420   jresult = (int)result;
43421   return jresult;
43422 }
43423
43424
43425 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43426   int jresult ;
43427   int result;
43428
43429   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43430   jresult = (int)result;
43431   return jresult;
43432 }
43433
43434
43435 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43436   int jresult ;
43437   int result;
43438
43439   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43440   jresult = (int)result;
43441   return jresult;
43442 }
43443
43444
43445 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43446   int jresult ;
43447   int result;
43448
43449   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43450   jresult = (int)result;
43451   return jresult;
43452 }
43453
43454
43455 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43456   int jresult ;
43457   int result;
43458
43459   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43460   jresult = (int)result;
43461   return jresult;
43462 }
43463
43464
43465 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43466   int jresult ;
43467   int result;
43468
43469   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43470   jresult = (int)result;
43471   return jresult;
43472 }
43473
43474
43475 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43476   int jresult ;
43477   int result;
43478
43479   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43480   jresult = (int)result;
43481   return jresult;
43482 }
43483
43484
43485 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TARGET_POSITION_get() {
43486   int jresult ;
43487   int result;
43488
43489   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43490   jresult = (int)result;
43491   return jresult;
43492 }
43493
43494
43495 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_PROJECTION_MATRIX_get() {
43496   int jresult ;
43497   int result;
43498
43499   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43500   jresult = (int)result;
43501   return jresult;
43502 }
43503
43504
43505 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_VIEW_MATRIX_get() {
43506   int jresult ;
43507   int result;
43508
43509   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43510   jresult = (int)result;
43511   return jresult;
43512 }
43513
43514
43515 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_INVERT_Y_AXIS_get() {
43516   int jresult ;
43517   int result;
43518
43519   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43520   jresult = (int)result;
43521   return jresult;
43522 }
43523
43524
43525 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor_Property() {
43526   void * jresult ;
43527   Dali::CameraActor::Property *result = 0 ;
43528
43529   {
43530     try {
43531       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43532     } catch (std::out_of_range& e) {
43533       {
43534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43535       };
43536     } catch (std::exception& e) {
43537       {
43538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43539       };
43540     } catch (...) {
43541       {
43542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43543       };
43544     }
43545   }
43546   jresult = (void *)result;
43547   return jresult;
43548 }
43549
43550
43551 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CameraActor_Property(void * jarg1) {
43552   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43553
43554   arg1 = (Dali::CameraActor::Property *)jarg1;
43555   {
43556     try {
43557       delete arg1;
43558     } catch (std::out_of_range& e) {
43559       {
43560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43561       };
43562     } catch (std::exception& e) {
43563       {
43564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43565       };
43566     } catch (...) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43569       };
43570     }
43571   }
43572 }
43573
43574
43575 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor__SWIG_0() {
43576   void * jresult ;
43577   Dali::CameraActor *result = 0 ;
43578
43579   {
43580     try {
43581       result = (Dali::CameraActor *)new Dali::CameraActor();
43582     } catch (std::out_of_range& e) {
43583       {
43584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43585       };
43586     } catch (std::exception& e) {
43587       {
43588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43589       };
43590     } catch (...) {
43591       {
43592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43593       };
43594     }
43595   }
43596   jresult = (void *)result;
43597   return jresult;
43598 }
43599
43600
43601 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_New__SWIG_0() {
43602   void * jresult ;
43603   Dali::CameraActor result;
43604
43605   {
43606     try {
43607       result = Dali::CameraActor::New();
43608     } catch (std::out_of_range& e) {
43609       {
43610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43611       };
43612     } catch (std::exception& e) {
43613       {
43614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43615       };
43616     } catch (...) {
43617       {
43618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43619       };
43620     }
43621   }
43622   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43623   return jresult;
43624 }
43625
43626
43627 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_New__SWIG_1(void * jarg1) {
43628   void * jresult ;
43629   Dali::Size *arg1 = 0 ;
43630   Dali::CameraActor result;
43631
43632   arg1 = (Dali::Size *)jarg1;
43633   if (!arg1) {
43634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43635     return 0;
43636   }
43637   {
43638     try {
43639       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43640     } catch (std::out_of_range& e) {
43641       {
43642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43643       };
43644     } catch (std::exception& e) {
43645       {
43646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43647       };
43648     } catch (...) {
43649       {
43650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43651       };
43652     }
43653   }
43654   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43655   return jresult;
43656 }
43657
43658
43659 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_DownCast(void * jarg1) {
43660   void * jresult ;
43661   Dali::BaseHandle arg1 ;
43662   Dali::BaseHandle *argp1 ;
43663   Dali::CameraActor result;
43664
43665   argp1 = (Dali::BaseHandle *)jarg1;
43666   if (!argp1) {
43667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43668     return 0;
43669   }
43670   arg1 = *argp1;
43671   {
43672     try {
43673       result = Dali::CameraActor::DownCast(arg1);
43674     } catch (std::out_of_range& e) {
43675       {
43676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43677       };
43678     } catch (std::exception& e) {
43679       {
43680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43681       };
43682     } catch (...) {
43683       {
43684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43685       };
43686     }
43687   }
43688   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43689   return jresult;
43690 }
43691
43692
43693 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CameraActor(void * jarg1) {
43694   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43695
43696   arg1 = (Dali::CameraActor *)jarg1;
43697   {
43698     try {
43699       delete arg1;
43700     } catch (std::out_of_range& e) {
43701       {
43702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43703       };
43704     } catch (std::exception& e) {
43705       {
43706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43711       };
43712     }
43713   }
43714 }
43715
43716
43717 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor__SWIG_1(void * jarg1) {
43718   void * jresult ;
43719   Dali::CameraActor *arg1 = 0 ;
43720   Dali::CameraActor *result = 0 ;
43721
43722   arg1 = (Dali::CameraActor *)jarg1;
43723   if (!arg1) {
43724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43725     return 0;
43726   }
43727   {
43728     try {
43729       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43730     } catch (std::out_of_range& e) {
43731       {
43732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43733       };
43734     } catch (std::exception& e) {
43735       {
43736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43737       };
43738     } catch (...) {
43739       {
43740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43741       };
43742     }
43743   }
43744   jresult = (void *)result;
43745   return jresult;
43746 }
43747
43748
43749 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_Assign(void * jarg1, void * jarg2) {
43750   void * jresult ;
43751   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43752   Dali::CameraActor *arg2 = 0 ;
43753   Dali::CameraActor *result = 0 ;
43754
43755   arg1 = (Dali::CameraActor *)jarg1;
43756   arg2 = (Dali::CameraActor *)jarg2;
43757   if (!arg2) {
43758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43759     return 0;
43760   }
43761   {
43762     try {
43763       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43764     } catch (std::out_of_range& e) {
43765       {
43766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43767       };
43768     } catch (std::exception& e) {
43769       {
43770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43771       };
43772     } catch (...) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43775       };
43776     }
43777   }
43778   jresult = (void *)result;
43779   return jresult;
43780 }
43781
43782
43783 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetType(void * jarg1, int jarg2) {
43784   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43785   Dali::Camera::Type arg2 ;
43786
43787   arg1 = (Dali::CameraActor *)jarg1;
43788   arg2 = (Dali::Camera::Type)jarg2;
43789   {
43790     try {
43791       (arg1)->SetType(arg2);
43792     } catch (std::out_of_range& e) {
43793       {
43794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43795       };
43796     } catch (std::exception& e) {
43797       {
43798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43799       };
43800     } catch (...) {
43801       {
43802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43803       };
43804     }
43805   }
43806 }
43807
43808
43809 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_GetType(void * jarg1) {
43810   int jresult ;
43811   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43812   Dali::Camera::Type result;
43813
43814   arg1 = (Dali::CameraActor *)jarg1;
43815   {
43816     try {
43817       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43818     } catch (std::out_of_range& e) {
43819       {
43820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43821       };
43822     } catch (std::exception& e) {
43823       {
43824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43825       };
43826     } catch (...) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43829       };
43830     }
43831   }
43832   jresult = (int)result;
43833   return jresult;
43834 }
43835
43836
43837 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43838   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43839   Dali::Camera::ProjectionMode arg2 ;
43840
43841   arg1 = (Dali::CameraActor *)jarg1;
43842   arg2 = (Dali::Camera::ProjectionMode)jarg2;
43843   {
43844     try {
43845       (arg1)->SetProjectionMode(arg2);
43846     } catch (std::out_of_range& e) {
43847       {
43848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43849       };
43850     } catch (std::exception& e) {
43851       {
43852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43853       };
43854     } catch (...) {
43855       {
43856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43857       };
43858     }
43859   }
43860 }
43861
43862
43863 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_GetProjectionMode(void * jarg1) {
43864   int jresult ;
43865   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43866   Dali::Camera::ProjectionMode result;
43867
43868   arg1 = (Dali::CameraActor *)jarg1;
43869   {
43870     try {
43871       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
43872     } catch (std::out_of_range& e) {
43873       {
43874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43875       };
43876     } catch (std::exception& e) {
43877       {
43878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43879       };
43880     } catch (...) {
43881       {
43882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43883       };
43884     }
43885   }
43886   jresult = (int)result;
43887   return jresult;
43888 }
43889
43890
43891 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
43892   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43893   float arg2 ;
43894
43895   arg1 = (Dali::CameraActor *)jarg1;
43896   arg2 = (float)jarg2;
43897   {
43898     try {
43899       (arg1)->SetFieldOfView(arg2);
43900     } catch (std::out_of_range& e) {
43901       {
43902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43903       };
43904     } catch (std::exception& e) {
43905       {
43906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43907       };
43908     } catch (...) {
43909       {
43910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43911       };
43912     }
43913   }
43914 }
43915
43916
43917 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetFieldOfView(void * jarg1) {
43918   float jresult ;
43919   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43920   float result;
43921
43922   arg1 = (Dali::CameraActor *)jarg1;
43923   {
43924     try {
43925       result = (float)(arg1)->GetFieldOfView();
43926     } catch (std::out_of_range& e) {
43927       {
43928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43929       };
43930     } catch (std::exception& e) {
43931       {
43932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43933       };
43934     } catch (...) {
43935       {
43936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43937       };
43938     }
43939   }
43940   jresult = result;
43941   return jresult;
43942 }
43943
43944
43945 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
43946   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43947   float arg2 ;
43948
43949   arg1 = (Dali::CameraActor *)jarg1;
43950   arg2 = (float)jarg2;
43951   {
43952     try {
43953       (arg1)->SetAspectRatio(arg2);
43954     } catch (std::out_of_range& e) {
43955       {
43956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43957       };
43958     } catch (std::exception& e) {
43959       {
43960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43961       };
43962     } catch (...) {
43963       {
43964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43965       };
43966     }
43967   }
43968 }
43969
43970
43971 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetAspectRatio(void * jarg1) {
43972   float jresult ;
43973   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43974   float result;
43975
43976   arg1 = (Dali::CameraActor *)jarg1;
43977   {
43978     try {
43979       result = (float)(arg1)->GetAspectRatio();
43980     } catch (std::out_of_range& e) {
43981       {
43982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43983       };
43984     } catch (std::exception& e) {
43985       {
43986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43987       };
43988     } catch (...) {
43989       {
43990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43991       };
43992     }
43993   }
43994   jresult = result;
43995   return jresult;
43996 }
43997
43998
43999 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44000   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44001   float arg2 ;
44002
44003   arg1 = (Dali::CameraActor *)jarg1;
44004   arg2 = (float)jarg2;
44005   {
44006     try {
44007       (arg1)->SetNearClippingPlane(arg2);
44008     } catch (std::out_of_range& e) {
44009       {
44010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44011       };
44012     } catch (std::exception& e) {
44013       {
44014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44015       };
44016     } catch (...) {
44017       {
44018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44019       };
44020     }
44021   }
44022 }
44023
44024
44025 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetNearClippingPlane(void * jarg1) {
44026   float jresult ;
44027   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44028   float result;
44029
44030   arg1 = (Dali::CameraActor *)jarg1;
44031   {
44032     try {
44033       result = (float)(arg1)->GetNearClippingPlane();
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44041       };
44042     } catch (...) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44045       };
44046     }
44047   }
44048   jresult = result;
44049   return jresult;
44050 }
44051
44052
44053 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44054   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44055   float arg2 ;
44056
44057   arg1 = (Dali::CameraActor *)jarg1;
44058   arg2 = (float)jarg2;
44059   {
44060     try {
44061       (arg1)->SetFarClippingPlane(arg2);
44062     } catch (std::out_of_range& e) {
44063       {
44064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44065       };
44066     } catch (std::exception& e) {
44067       {
44068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44069       };
44070     } catch (...) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44073       };
44074     }
44075   }
44076 }
44077
44078
44079 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetFarClippingPlane(void * jarg1) {
44080   float jresult ;
44081   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44082   float result;
44083
44084   arg1 = (Dali::CameraActor *)jarg1;
44085   {
44086     try {
44087       result = (float)(arg1)->GetFarClippingPlane();
44088     } catch (std::out_of_range& e) {
44089       {
44090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44091       };
44092     } catch (std::exception& e) {
44093       {
44094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44095       };
44096     } catch (...) {
44097       {
44098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44099       };
44100     }
44101   }
44102   jresult = result;
44103   return jresult;
44104 }
44105
44106
44107 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44108   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44109   Dali::Vector3 *arg2 = 0 ;
44110
44111   arg1 = (Dali::CameraActor *)jarg1;
44112   arg2 = (Dali::Vector3 *)jarg2;
44113   if (!arg2) {
44114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44115     return ;
44116   }
44117   {
44118     try {
44119       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44120     } catch (std::out_of_range& e) {
44121       {
44122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44123       };
44124     } catch (std::exception& e) {
44125       {
44126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44127       };
44128     } catch (...) {
44129       {
44130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44131       };
44132     }
44133   }
44134 }
44135
44136
44137 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_GetTargetPosition(void * jarg1) {
44138   void * jresult ;
44139   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44140   Dali::Vector3 result;
44141
44142   arg1 = (Dali::CameraActor *)jarg1;
44143   {
44144     try {
44145       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44146     } catch (std::out_of_range& e) {
44147       {
44148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44149       };
44150     } catch (std::exception& e) {
44151       {
44152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44153       };
44154     } catch (...) {
44155       {
44156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44157       };
44158     }
44159   }
44160   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44161   return jresult;
44162 }
44163
44164
44165 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44166   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44167   bool arg2 ;
44168
44169   arg1 = (Dali::CameraActor *)jarg1;
44170   arg2 = jarg2 ? true : false;
44171   {
44172     try {
44173       (arg1)->SetInvertYAxis(arg2);
44174     } catch (std::out_of_range& e) {
44175       {
44176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44177       };
44178     } catch (std::exception& e) {
44179       {
44180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44181       };
44182     } catch (...) {
44183       {
44184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44185       };
44186     }
44187   }
44188 }
44189
44190
44191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CameraActor_GetInvertYAxis(void * jarg1) {
44192   unsigned int jresult ;
44193   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44194   bool result;
44195
44196   arg1 = (Dali::CameraActor *)jarg1;
44197   {
44198     try {
44199       result = (bool)(arg1)->GetInvertYAxis();
44200     } catch (std::out_of_range& e) {
44201       {
44202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44203       };
44204     } catch (std::exception& e) {
44205       {
44206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44207       };
44208     } catch (...) {
44209       {
44210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44211       };
44212     }
44213   }
44214   jresult = result;
44215   return jresult;
44216 }
44217
44218
44219 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44220   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44221   Dali::Size *arg2 = 0 ;
44222
44223   arg1 = (Dali::CameraActor *)jarg1;
44224   arg2 = (Dali::Size *)jarg2;
44225   if (!arg2) {
44226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44227     return ;
44228   }
44229   {
44230     try {
44231       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44232     } catch (std::out_of_range& e) {
44233       {
44234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44235       };
44236     } catch (std::exception& e) {
44237       {
44238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44239       };
44240     } catch (...) {
44241       {
44242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44243       };
44244     }
44245   }
44246 }
44247
44248
44249 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44251   Dali::Size *arg2 = 0 ;
44252
44253   arg1 = (Dali::CameraActor *)jarg1;
44254   arg2 = (Dali::Size *)jarg2;
44255   if (!arg2) {
44256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44257     return ;
44258   }
44259   {
44260     try {
44261       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44262     } catch (std::out_of_range& e) {
44263       {
44264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44265       };
44266     } catch (std::exception& e) {
44267       {
44268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44269       };
44270     } catch (...) {
44271       {
44272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44273       };
44274     }
44275   }
44276 }
44277
44278
44279 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44280   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44281   float arg2 ;
44282   float arg3 ;
44283   float arg4 ;
44284   float arg5 ;
44285   float arg6 ;
44286   float arg7 ;
44287
44288   arg1 = (Dali::CameraActor *)jarg1;
44289   arg2 = (float)jarg2;
44290   arg3 = (float)jarg3;
44291   arg4 = (float)jarg4;
44292   arg5 = (float)jarg5;
44293   arg6 = (float)jarg6;
44294   arg7 = (float)jarg7;
44295   {
44296     try {
44297       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44298     } catch (std::out_of_range& e) {
44299       {
44300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44301       };
44302     } catch (std::exception& e) {
44303       {
44304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44305       };
44306     } catch (...) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44309       };
44310     }
44311   }
44312 }
44313
44314
44315 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_0() {
44316   void * jresult ;
44317   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44318
44319   {
44320     try {
44321       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44322     } catch (std::out_of_range& e) {
44323       {
44324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44325       };
44326     } catch (std::exception& e) {
44327       {
44328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (...) {
44331       {
44332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44333       };
44334     }
44335   }
44336   jresult = (void *)result;
44337   return jresult;
44338 }
44339
44340
44341 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44342   void * jresult ;
44343   std::string arg1 ;
44344   Dali::Property::Value arg2 ;
44345   Dali::Property::Value *argp2 ;
44346   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44347
44348   if (!jarg1) {
44349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44350     return 0;
44351   }
44352   (&arg1)->assign(jarg1);
44353   argp2 = (Dali::Property::Value *)jarg2;
44354   if (!argp2) {
44355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44356     return 0;
44357   }
44358   arg2 = *argp2;
44359   {
44360     try {
44361       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44362     } catch (std::out_of_range& e) {
44363       {
44364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44365       };
44366     } catch (std::exception& e) {
44367       {
44368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44369       };
44370     } catch (...) {
44371       {
44372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44373       };
44374     }
44375   }
44376   jresult = (void *)result;
44377   return jresult;
44378 }
44379
44380
44381 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_2(void * jarg1) {
44382   void * jresult ;
44383   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44384   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44385
44386   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44387   if (!arg1) {
44388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44389     return 0;
44390   }
44391   {
44392     try {
44393       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);
44394     } catch (std::out_of_range& e) {
44395       {
44396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (std::exception& e) {
44399       {
44400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44401       };
44402     } catch (...) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44405       };
44406     }
44407   }
44408   jresult = (void *)result;
44409   return jresult;
44410 }
44411
44412
44413 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StringValuePair_first_set(void * jarg1, char * jarg2) {
44414   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44415   std::string *arg2 = 0 ;
44416
44417   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44418   if (!jarg2) {
44419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44420     return ;
44421   }
44422   std::string arg2_str(jarg2);
44423   arg2 = &arg2_str;
44424   if (arg1) (arg1)->first = *arg2;
44425
44426   //argout typemap for const std::string&
44427
44428 }
44429
44430
44431 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_StringValuePair_first_get(void * jarg1) {
44432   char * jresult ;
44433   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44434   std::string *result = 0 ;
44435
44436   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44437   result = (std::string *) & ((arg1)->first);
44438   jresult = SWIG_csharp_string_callback(result->c_str());
44439   return jresult;
44440 }
44441
44442
44443 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StringValuePair_second_set(void * jarg1, void * jarg2) {
44444   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44445   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44446
44447   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44448   arg2 = (Dali::Property::Value *)jarg2;
44449   if (arg1) (arg1)->second = *arg2;
44450 }
44451
44452
44453 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StringValuePair_second_get(void * jarg1) {
44454   void * jresult ;
44455   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44456   Dali::Property::Value *result = 0 ;
44457
44458   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44459   result = (Dali::Property::Value *)& ((arg1)->second);
44460   jresult = (void *)result;
44461   return jresult;
44462 }
44463
44464
44465 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StringValuePair(void * jarg1) {
44466   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44467
44468   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44469   {
44470     try {
44471       delete arg1;
44472     } catch (std::out_of_range& e) {
44473       {
44474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44475       };
44476     } catch (std::exception& e) {
44477       {
44478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44479       };
44480     } catch (...) {
44481       {
44482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44483       };
44484     }
44485   }
44486 }
44487
44488
44489 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Clear(void * jarg1) {
44490   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44491
44492   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44493   {
44494     try {
44495       (arg1)->clear();
44496     } catch (std::out_of_range& e) {
44497       {
44498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44499       };
44500     } catch (std::exception& e) {
44501       {
44502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44503       };
44504     } catch (...) {
44505       {
44506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44507       };
44508     }
44509   }
44510 }
44511
44512
44513 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44514   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44515   Dali::TouchPoint *arg2 = 0 ;
44516
44517   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44518   arg2 = (Dali::TouchPoint *)jarg2;
44519   if (!arg2) {
44520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44521     return ;
44522   }
44523   {
44524     try {
44525       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44526     } catch (std::out_of_range& e) {
44527       {
44528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44529       };
44530     } catch (std::exception& e) {
44531       {
44532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44533       };
44534     } catch (...) {
44535       {
44536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44537       };
44538     }
44539   }
44540 }
44541
44542
44543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchPointContainer_size(void * jarg1) {
44544   unsigned long jresult ;
44545   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44546   std::vector< Dali::TouchPoint >::size_type result;
44547
44548   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44549   {
44550     try {
44551       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44552     } catch (std::out_of_range& e) {
44553       {
44554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44555       };
44556     } catch (std::exception& e) {
44557       {
44558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44559       };
44560     } catch (...) {
44561       {
44562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44563       };
44564     }
44565   }
44566   jresult = (unsigned long)result;
44567   return jresult;
44568 }
44569
44570
44571 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchPointContainer_capacity(void * jarg1) {
44572   unsigned long jresult ;
44573   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44574   std::vector< Dali::TouchPoint >::size_type result;
44575
44576   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44577   {
44578     try {
44579       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44580     } catch (std::out_of_range& e) {
44581       {
44582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44583       };
44584     } catch (std::exception& e) {
44585       {
44586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44587       };
44588     } catch (...) {
44589       {
44590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44591       };
44592     }
44593   }
44594   jresult = (unsigned long)result;
44595   return jresult;
44596 }
44597
44598
44599 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44600   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44601   std::vector< Dali::TouchPoint >::size_type arg2 ;
44602
44603   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44604   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44605   {
44606     try {
44607       (arg1)->reserve(arg2);
44608     } catch (std::out_of_range& e) {
44609       {
44610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44611       };
44612     } catch (std::exception& e) {
44613       {
44614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44615       };
44616     } catch (...) {
44617       {
44618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44619       };
44620     }
44621   }
44622 }
44623
44624
44625 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_0() {
44626   void * jresult ;
44627   std::vector< Dali::TouchPoint > *result = 0 ;
44628
44629   {
44630     try {
44631       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44632     } catch (std::out_of_range& e) {
44633       {
44634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44635       };
44636     } catch (std::exception& e) {
44637       {
44638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44639       };
44640     } catch (...) {
44641       {
44642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44643       };
44644     }
44645   }
44646   jresult = (void *)result;
44647   return jresult;
44648 }
44649
44650
44651 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_1(void * jarg1) {
44652   void * jresult ;
44653   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44654   std::vector< Dali::TouchPoint > *result = 0 ;
44655
44656   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44657   if (!arg1) {
44658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44659     return 0;
44660   }
44661   {
44662     try {
44663       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44664     } catch (std::out_of_range& e) {
44665       {
44666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44667       };
44668     } catch (std::exception& e) {
44669       {
44670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44671       };
44672     } catch (...) {
44673       {
44674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44675       };
44676     }
44677   }
44678   jresult = (void *)result;
44679   return jresult;
44680 }
44681
44682
44683 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_2(int jarg1) {
44684   void * jresult ;
44685   int arg1 ;
44686   std::vector< Dali::TouchPoint > *result = 0 ;
44687
44688   arg1 = (int)jarg1;
44689   {
44690     try {
44691       try {
44692         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44693       }
44694       catch(std::out_of_range &_e) {
44695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44696         return 0;
44697       }
44698
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44710       };
44711     }
44712   }
44713   jresult = (void *)result;
44714   return jresult;
44715 }
44716
44717
44718 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44719   void * jresult ;
44720   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44721   int arg2 ;
44722   SwigValueWrapper< Dali::TouchPoint > result;
44723
44724   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44725   arg2 = (int)jarg2;
44726   {
44727     try {
44728       try {
44729         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44730       }
44731       catch(std::out_of_range &_e) {
44732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44733         return 0;
44734       }
44735
44736     } catch (std::out_of_range& e) {
44737       {
44738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44739       };
44740     } catch (std::exception& e) {
44741       {
44742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44743       };
44744     } catch (...) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44747       };
44748     }
44749   }
44750   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44751   return jresult;
44752 }
44753
44754
44755 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44756   void * jresult ;
44757   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44758   int arg2 ;
44759   Dali::TouchPoint *result = 0 ;
44760
44761   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44762   arg2 = (int)jarg2;
44763   {
44764     try {
44765       try {
44766         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44767       }
44768       catch(std::out_of_range &_e) {
44769         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44770         return 0;
44771       }
44772
44773     } catch (std::out_of_range& e) {
44774       {
44775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44776       };
44777     } catch (std::exception& e) {
44778       {
44779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44780       };
44781     } catch (...) {
44782       {
44783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44784       };
44785     }
44786   }
44787   jresult = (void *)result;
44788   return jresult;
44789 }
44790
44791
44792 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44793   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44794   int arg2 ;
44795   Dali::TouchPoint *arg3 = 0 ;
44796
44797   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44798   arg2 = (int)jarg2;
44799   arg3 = (Dali::TouchPoint *)jarg3;
44800   if (!arg3) {
44801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44802     return ;
44803   }
44804   {
44805     try {
44806       try {
44807         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44808       }
44809       catch(std::out_of_range &_e) {
44810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44811         return ;
44812       }
44813
44814     } catch (std::out_of_range& e) {
44815       {
44816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44817       };
44818     } catch (std::exception& e) {
44819       {
44820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44821       };
44822     } catch (...) {
44823       {
44824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44825       };
44826     }
44827   }
44828 }
44829
44830
44831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44832   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44833   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44834
44835   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44836   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44837   if (!arg2) {
44838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44839     return ;
44840   }
44841   {
44842     try {
44843       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
44844     } catch (std::out_of_range& e) {
44845       {
44846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44847       };
44848     } catch (std::exception& e) {
44849       {
44850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44851       };
44852     } catch (...) {
44853       {
44854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44855       };
44856     }
44857   }
44858 }
44859
44860
44861 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
44862   void * jresult ;
44863   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44864   int arg2 ;
44865   int arg3 ;
44866   std::vector< Dali::TouchPoint > *result = 0 ;
44867
44868   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44869   arg2 = (int)jarg2;
44870   arg3 = (int)jarg3;
44871   {
44872     try {
44873       try {
44874         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
44875       }
44876       catch(std::out_of_range &_e) {
44877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44878         return 0;
44879       }
44880       catch(std::invalid_argument &_e) {
44881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44882         return 0;
44883       }
44884
44885     } catch (std::out_of_range& e) {
44886       {
44887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44888       };
44889     } catch (std::exception& e) {
44890       {
44891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44892       };
44893     } catch (...) {
44894       {
44895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44896       };
44897     }
44898   }
44899   jresult = (void *)result;
44900   return jresult;
44901 }
44902
44903
44904 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
44905   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44906   int arg2 ;
44907   Dali::TouchPoint *arg3 = 0 ;
44908
44909   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44910   arg2 = (int)jarg2;
44911   arg3 = (Dali::TouchPoint *)jarg3;
44912   if (!arg3) {
44913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44914     return ;
44915   }
44916   {
44917     try {
44918       try {
44919         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44920       }
44921       catch(std::out_of_range &_e) {
44922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44923         return ;
44924       }
44925
44926     } catch (std::out_of_range& e) {
44927       {
44928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44929       };
44930     } catch (std::exception& e) {
44931       {
44932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44933       };
44934     } catch (...) {
44935       {
44936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44937       };
44938     }
44939   }
44940 }
44941
44942
44943 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
44944   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44945   int arg2 ;
44946   std::vector< Dali::TouchPoint > *arg3 = 0 ;
44947
44948   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44949   arg2 = (int)jarg2;
44950   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
44951   if (!arg3) {
44952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44953     return ;
44954   }
44955   {
44956     try {
44957       try {
44958         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
44959       }
44960       catch(std::out_of_range &_e) {
44961         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44962         return ;
44963       }
44964
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_NUI_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
44983   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44984   int arg2 ;
44985
44986   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44987   arg2 = (int)jarg2;
44988   {
44989     try {
44990       try {
44991         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
44992       }
44993       catch(std::out_of_range &_e) {
44994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44995         return ;
44996       }
44997
44998     } catch (std::out_of_range& e) {
44999       {
45000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45001       };
45002     } catch (std::exception& e) {
45003       {
45004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45005       };
45006     } catch (...) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45009       };
45010     }
45011   }
45012 }
45013
45014
45015 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45016   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45017   int arg2 ;
45018   int arg3 ;
45019
45020   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45021   arg2 = (int)jarg2;
45022   arg3 = (int)jarg3;
45023   {
45024     try {
45025       try {
45026         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45027       }
45028       catch(std::out_of_range &_e) {
45029         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45030         return ;
45031       }
45032       catch(std::invalid_argument &_e) {
45033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45034         return ;
45035       }
45036
45037     } catch (std::out_of_range& e) {
45038       {
45039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45040       };
45041     } catch (std::exception& e) {
45042       {
45043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45044       };
45045     } catch (...) {
45046       {
45047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45048       };
45049     }
45050   }
45051 }
45052
45053
45054 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45055   void * jresult ;
45056   Dali::TouchPoint *arg1 = 0 ;
45057   int arg2 ;
45058   std::vector< Dali::TouchPoint > *result = 0 ;
45059
45060   arg1 = (Dali::TouchPoint *)jarg1;
45061   if (!arg1) {
45062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45063     return 0;
45064   }
45065   arg2 = (int)jarg2;
45066   {
45067     try {
45068       try {
45069         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45070       }
45071       catch(std::out_of_range &_e) {
45072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45073         return 0;
45074       }
45075
45076     } catch (std::out_of_range& e) {
45077       {
45078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45079       };
45080     } catch (std::exception& e) {
45081       {
45082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45083       };
45084     } catch (...) {
45085       {
45086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45087       };
45088     }
45089   }
45090   jresult = (void *)result;
45091   return jresult;
45092 }
45093
45094
45095 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45096   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45097
45098   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45099   {
45100     try {
45101       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45102     } catch (std::out_of_range& e) {
45103       {
45104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45105       };
45106     } catch (std::exception& e) {
45107       {
45108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45109       };
45110     } catch (...) {
45111       {
45112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45113       };
45114     }
45115   }
45116 }
45117
45118
45119 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45120   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45121   int arg2 ;
45122   int arg3 ;
45123
45124   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45125   arg2 = (int)jarg2;
45126   arg3 = (int)jarg3;
45127   {
45128     try {
45129       try {
45130         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45131       }
45132       catch(std::out_of_range &_e) {
45133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45134         return ;
45135       }
45136       catch(std::invalid_argument &_e) {
45137         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45138         return ;
45139       }
45140
45141     } catch (std::out_of_range& e) {
45142       {
45143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45144       };
45145     } catch (std::exception& e) {
45146       {
45147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45148       };
45149     } catch (...) {
45150       {
45151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45152       };
45153     }
45154   }
45155 }
45156
45157
45158 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45159   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45160   int arg2 ;
45161   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45162
45163   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45164   arg2 = (int)jarg2;
45165   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45166   if (!arg3) {
45167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45168     return ;
45169   }
45170   {
45171     try {
45172       try {
45173         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45174       }
45175       catch(std::out_of_range &_e) {
45176         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45177         return ;
45178       }
45179
45180     } catch (std::out_of_range& e) {
45181       {
45182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45183       };
45184     } catch (std::exception& e) {
45185       {
45186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45187       };
45188     } catch (...) {
45189       {
45190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45191       };
45192     }
45193   }
45194 }
45195
45196
45197 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchPointContainer(void * jarg1) {
45198   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45199
45200   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45201   {
45202     try {
45203       delete arg1;
45204     } catch (std::out_of_range& e) {
45205       {
45206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45207       };
45208     } catch (std::exception& e) {
45209       {
45210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45211       };
45212     } catch (...) {
45213       {
45214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45215       };
45216     }
45217   }
45218 }
45219
45220
45221 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_0() {
45222   void * jresult ;
45223   Dali::Rect< double > *result = 0 ;
45224
45225   {
45226     try {
45227       result = (Dali::Rect< double > *)new Dali::Rect< double >();
45228     } catch (std::out_of_range& e) {
45229       {
45230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (std::exception& e) {
45233       {
45234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (...) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45239       };
45240     }
45241   }
45242   jresult = (void *)result;
45243   return jresult;
45244 }
45245
45246
45247 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4) {
45248   void * jresult ;
45249   double arg1 ;
45250   double arg2 ;
45251   double arg3 ;
45252   double arg4 ;
45253   Dali::Rect< double > *result = 0 ;
45254
45255   arg1 = (double)jarg1;
45256   arg2 = (double)jarg2;
45257   arg3 = (double)jarg3;
45258   arg4 = (double)jarg4;
45259   {
45260     try {
45261       result = (Dali::Rect< double > *)new Dali::Rect< double >(arg1,arg2,arg3,arg4);
45262     } catch (std::out_of_range& e) {
45263       {
45264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45265       };
45266     } catch (std::exception& e) {
45267       {
45268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45269       };
45270     } catch (...) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45273       };
45274     }
45275   }
45276   jresult = (void *)result;
45277   return jresult;
45278 }
45279
45280
45281 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_2(void * jarg1) {
45282   void * jresult ;
45283   Dali::Rect< double > *arg1 = 0 ;
45284   Dali::Rect< double > *result = 0 ;
45285
45286   arg1 = (Dali::Rect< double > *)jarg1;
45287   if (!arg1) {
45288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45289     return 0;
45290   }
45291   {
45292     try {
45293       result = (Dali::Rect< double > *)new Dali::Rect< double >((Dali::Rect< double > const &)*arg1);
45294     } catch (std::out_of_range& e) {
45295       {
45296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45297       };
45298     } catch (std::exception& e) {
45299       {
45300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45301       };
45302     } catch (...) {
45303       {
45304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45305       };
45306     }
45307   }
45308   jresult = (void *)result;
45309   return jresult;
45310 }
45311
45312
45313 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectDouble_Assign(void * jarg1, void * jarg2) {
45314   void * jresult ;
45315   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45316   Dali::Rect< double > *arg2 = 0 ;
45317   Dali::Rect< double > *result = 0 ;
45318
45319   arg1 = (Dali::Rect< double > *)jarg1;
45320   arg2 = (Dali::Rect< double > *)jarg2;
45321   if (!arg2) {
45322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45323     return 0;
45324   }
45325   {
45326     try {
45327       result = (Dali::Rect< double > *) &(arg1)->operator =((Dali::Rect< double > const &)*arg2);
45328     } catch (std::out_of_range& e) {
45329       {
45330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45331       };
45332     } catch (std::exception& e) {
45333       {
45334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45335       };
45336     } catch (...) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45339       };
45340     }
45341   }
45342   jresult = (void *)result;
45343   return jresult;
45344 }
45345
45346
45347 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_Set(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
45348   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45349   double arg2 ;
45350   double arg3 ;
45351   double arg4 ;
45352   double arg5 ;
45353
45354   arg1 = (Dali::Rect< double > *)jarg1;
45355   arg2 = (double)jarg2;
45356   arg3 = (double)jarg3;
45357   arg4 = (double)jarg4;
45358   arg5 = (double)jarg5;
45359   {
45360     try {
45361       (arg1)->Set(arg2,arg3,arg4,arg5);
45362     } catch (std::out_of_range& e) {
45363       {
45364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45365       };
45366     } catch (std::exception& e) {
45367       {
45368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45369       };
45370     } catch (...) {
45371       {
45372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45373       };
45374     }
45375   }
45376 }
45377
45378
45379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_IsEmpty(void * jarg1) {
45380   unsigned int jresult ;
45381   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45382   bool result;
45383
45384   arg1 = (Dali::Rect< double > *)jarg1;
45385   {
45386     try {
45387       result = (bool)((Dali::Rect< double > const *)arg1)->IsEmpty();
45388     } catch (std::out_of_range& e) {
45389       {
45390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45391       };
45392     } catch (std::exception& e) {
45393       {
45394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45395       };
45396     } catch (...) {
45397       {
45398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45399       };
45400     }
45401   }
45402   jresult = result;
45403   return jresult;
45404 }
45405
45406
45407 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Left(void * jarg1) {
45408   double jresult ;
45409   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45410   double result;
45411
45412   arg1 = (Dali::Rect< double > *)jarg1;
45413   {
45414     try {
45415       result = (double)((Dali::Rect< double > const *)arg1)->Left();
45416     } catch (std::out_of_range& e) {
45417       {
45418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45419       };
45420     } catch (std::exception& e) {
45421       {
45422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45423       };
45424     } catch (...) {
45425       {
45426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45427       };
45428     }
45429   }
45430   jresult = result;
45431   return jresult;
45432 }
45433
45434
45435 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Right(void * jarg1) {
45436   double jresult ;
45437   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45438   double result;
45439
45440   arg1 = (Dali::Rect< double > *)jarg1;
45441   {
45442     try {
45443       result = (double)((Dali::Rect< double > const *)arg1)->Right();
45444     } catch (std::out_of_range& e) {
45445       {
45446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45447       };
45448     } catch (std::exception& e) {
45449       {
45450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45451       };
45452     } catch (...) {
45453       {
45454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45455       };
45456     }
45457   }
45458   jresult = result;
45459   return jresult;
45460 }
45461
45462
45463 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Top(void * jarg1) {
45464   double jresult ;
45465   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45466   double result;
45467
45468   arg1 = (Dali::Rect< double > *)jarg1;
45469   {
45470     try {
45471       result = (double)((Dali::Rect< double > const *)arg1)->Top();
45472     } catch (std::out_of_range& e) {
45473       {
45474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45475       };
45476     } catch (std::exception& e) {
45477       {
45478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45479       };
45480     } catch (...) {
45481       {
45482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45483       };
45484     }
45485   }
45486   jresult = result;
45487   return jresult;
45488 }
45489
45490
45491 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Bottom(void * jarg1) {
45492   double jresult ;
45493   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45494   double result;
45495
45496   arg1 = (Dali::Rect< double > *)jarg1;
45497   {
45498     try {
45499       result = (double)((Dali::Rect< double > const *)arg1)->Bottom();
45500     } catch (std::out_of_range& e) {
45501       {
45502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (std::exception& e) {
45505       {
45506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (...) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45511       };
45512     }
45513   }
45514   jresult = result;
45515   return jresult;
45516 }
45517
45518
45519 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Area(void * jarg1) {
45520   double jresult ;
45521   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45522   double result;
45523
45524   arg1 = (Dali::Rect< double > *)jarg1;
45525   {
45526     try {
45527       result = (double)((Dali::Rect< double > const *)arg1)->Area();
45528     } catch (std::out_of_range& e) {
45529       {
45530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45531       };
45532     } catch (std::exception& e) {
45533       {
45534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45535       };
45536     } catch (...) {
45537       {
45538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45539       };
45540     }
45541   }
45542   jresult = result;
45543   return jresult;
45544 }
45545
45546
45547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_Intersects(void * jarg1, void * jarg2) {
45548   unsigned int jresult ;
45549   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45550   Dali::Rect< double > *arg2 = 0 ;
45551   bool result;
45552
45553   arg1 = (Dali::Rect< double > *)jarg1;
45554   arg2 = (Dali::Rect< double > *)jarg2;
45555   if (!arg2) {
45556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45557     return 0;
45558   }
45559   {
45560     try {
45561       result = (bool)((Dali::Rect< double > const *)arg1)->Intersects((Dali::Rect< double > const &)*arg2);
45562     } catch (std::out_of_range& e) {
45563       {
45564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45565       };
45566     } catch (std::exception& e) {
45567       {
45568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45569       };
45570     } catch (...) {
45571       {
45572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45573       };
45574     }
45575   }
45576   jresult = result;
45577   return jresult;
45578 }
45579
45580
45581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_Contains(void * jarg1, void * jarg2) {
45582   unsigned int jresult ;
45583   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45584   Dali::Rect< double > *arg2 = 0 ;
45585   bool result;
45586
45587   arg1 = (Dali::Rect< double > *)jarg1;
45588   arg2 = (Dali::Rect< double > *)jarg2;
45589   if (!arg2) {
45590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45591     return 0;
45592   }
45593   {
45594     try {
45595       result = (bool)((Dali::Rect< double > const *)arg1)->Contains((Dali::Rect< double > const &)*arg2);
45596     } catch (std::out_of_range& e) {
45597       {
45598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (std::exception& e) {
45601       {
45602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45607       };
45608     }
45609   }
45610   jresult = result;
45611   return jresult;
45612 }
45613
45614
45615 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_x_set(void * jarg1, double jarg2) {
45616   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45617   double arg2 ;
45618
45619   arg1 = (Dali::Rect< double > *)jarg1;
45620   arg2 = (double)jarg2;
45621   if (arg1) (arg1)->x = arg2;
45622 }
45623
45624
45625 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_x_get(void * jarg1) {
45626   double jresult ;
45627   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45628   double result;
45629
45630   arg1 = (Dali::Rect< double > *)jarg1;
45631   result = (double) ((arg1)->x);
45632   jresult = result;
45633   return jresult;
45634 }
45635
45636
45637 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_left_set(void * jarg1, double jarg2) {
45638   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45639   double arg2 ;
45640
45641   arg1 = (Dali::Rect< double > *)jarg1;
45642   arg2 = (double)jarg2;
45643   if (arg1) (arg1)->left = arg2;
45644 }
45645
45646
45647 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_left_get(void * jarg1) {
45648   double jresult ;
45649   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45650   double result;
45651
45652   arg1 = (Dali::Rect< double > *)jarg1;
45653   result = (double) ((arg1)->left);
45654   jresult = result;
45655   return jresult;
45656 }
45657
45658
45659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_y_set(void * jarg1, double jarg2) {
45660   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45661   double arg2 ;
45662
45663   arg1 = (Dali::Rect< double > *)jarg1;
45664   arg2 = (double)jarg2;
45665   if (arg1) (arg1)->y = arg2;
45666 }
45667
45668
45669 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_y_get(void * jarg1) {
45670   double jresult ;
45671   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45672   double result;
45673
45674   arg1 = (Dali::Rect< double > *)jarg1;
45675   result = (double) ((arg1)->y);
45676   jresult = result;
45677   return jresult;
45678 }
45679
45680
45681 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_right_set(void * jarg1, double jarg2) {
45682   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45683   double arg2 ;
45684
45685   arg1 = (Dali::Rect< double > *)jarg1;
45686   arg2 = (double)jarg2;
45687   if (arg1) (arg1)->right = arg2;
45688 }
45689
45690
45691 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_right_get(void * jarg1) {
45692   double jresult ;
45693   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45694   double result;
45695
45696   arg1 = (Dali::Rect< double > *)jarg1;
45697   result = (double) ((arg1)->right);
45698   jresult = result;
45699   return jresult;
45700 }
45701
45702
45703 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_width_set(void * jarg1, double jarg2) {
45704   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45705   double arg2 ;
45706
45707   arg1 = (Dali::Rect< double > *)jarg1;
45708   arg2 = (double)jarg2;
45709   if (arg1) (arg1)->width = arg2;
45710 }
45711
45712
45713 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_width_get(void * jarg1) {
45714   double jresult ;
45715   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45716   double result;
45717
45718   arg1 = (Dali::Rect< double > *)jarg1;
45719   result = (double) ((arg1)->width);
45720   jresult = result;
45721   return jresult;
45722 }
45723
45724
45725 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_bottom_set(void * jarg1, double jarg2) {
45726   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45727   double arg2 ;
45728
45729   arg1 = (Dali::Rect< double > *)jarg1;
45730   arg2 = (double)jarg2;
45731   if (arg1) (arg1)->bottom = arg2;
45732 }
45733
45734
45735 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_bottom_get(void * jarg1) {
45736   double jresult ;
45737   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45738   double result;
45739
45740   arg1 = (Dali::Rect< double > *)jarg1;
45741   result = (double) ((arg1)->bottom);
45742   jresult = result;
45743   return jresult;
45744 }
45745
45746
45747 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_height_set(void * jarg1, double jarg2) {
45748   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45749   double arg2 ;
45750
45751   arg1 = (Dali::Rect< double > *)jarg1;
45752   arg2 = (double)jarg2;
45753   if (arg1) (arg1)->height = arg2;
45754 }
45755
45756
45757 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_height_get(void * jarg1) {
45758   double jresult ;
45759   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45760   double result;
45761
45762   arg1 = (Dali::Rect< double > *)jarg1;
45763   result = (double) ((arg1)->height);
45764   jresult = result;
45765   return jresult;
45766 }
45767
45768
45769 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_top_set(void * jarg1, double jarg2) {
45770   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45771   double arg2 ;
45772
45773   arg1 = (Dali::Rect< double > *)jarg1;
45774   arg2 = (double)jarg2;
45775   if (arg1) (arg1)->top = arg2;
45776 }
45777
45778
45779 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_top_get(void * jarg1) {
45780   double jresult ;
45781   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45782   double result;
45783
45784   arg1 = (Dali::Rect< double > *)jarg1;
45785   result = (double) ((arg1)->top);
45786   jresult = result;
45787   return jresult;
45788 }
45789
45790
45791 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectDouble(void * jarg1) {
45792   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45793
45794   arg1 = (Dali::Rect< double > *)jarg1;
45795   {
45796     try {
45797       delete arg1;
45798     } catch (std::out_of_range& e) {
45799       {
45800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45801       };
45802     } catch (std::exception& e) {
45803       {
45804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45805       };
45806     } catch (...) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45809       };
45810     }
45811   }
45812 }
45813
45814
45815 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_0() {
45816   void * jresult ;
45817   Dali::Rect< int > *result = 0 ;
45818
45819   {
45820     try {
45821       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45822     } catch (std::out_of_range& e) {
45823       {
45824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45825       };
45826     } catch (std::exception& e) {
45827       {
45828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (...) {
45831       {
45832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45833       };
45834     }
45835   }
45836   jresult = (void *)result;
45837   return jresult;
45838 }
45839
45840
45841 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45842   void * jresult ;
45843   int arg1 ;
45844   int arg2 ;
45845   int arg3 ;
45846   int arg4 ;
45847   Dali::Rect< int > *result = 0 ;
45848
45849   arg1 = (int)jarg1;
45850   arg2 = (int)jarg2;
45851   arg3 = (int)jarg3;
45852   arg4 = (int)jarg4;
45853   {
45854     try {
45855       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45856     } catch (std::out_of_range& e) {
45857       {
45858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45859       };
45860     } catch (std::exception& e) {
45861       {
45862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45863       };
45864     } catch (...) {
45865       {
45866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45867       };
45868     }
45869   }
45870   jresult = (void *)result;
45871   return jresult;
45872 }
45873
45874
45875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_2(void * jarg1) {
45876   void * jresult ;
45877   Dali::Rect< int > *arg1 = 0 ;
45878   Dali::Rect< int > *result = 0 ;
45879
45880   arg1 = (Dali::Rect< int > *)jarg1;
45881   if (!arg1) {
45882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45883     return 0;
45884   }
45885   {
45886     try {
45887       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45888     } catch (std::out_of_range& e) {
45889       {
45890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45891       };
45892     } catch (std::exception& e) {
45893       {
45894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45895       };
45896     } catch (...) {
45897       {
45898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45899       };
45900     }
45901   }
45902   jresult = (void *)result;
45903   return jresult;
45904 }
45905
45906
45907 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectInteger_Assign(void * jarg1, void * jarg2) {
45908   void * jresult ;
45909   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45910   Dali::Rect< int > *arg2 = 0 ;
45911   Dali::Rect< int > *result = 0 ;
45912
45913   arg1 = (Dali::Rect< int > *)jarg1;
45914   arg2 = (Dali::Rect< int > *)jarg2;
45915   if (!arg2) {
45916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45917     return 0;
45918   }
45919   {
45920     try {
45921       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45922     } catch (std::out_of_range& e) {
45923       {
45924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45925       };
45926     } catch (std::exception& e) {
45927       {
45928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45929       };
45930     } catch (...) {
45931       {
45932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45933       };
45934     }
45935   }
45936   jresult = (void *)result;
45937   return jresult;
45938 }
45939
45940
45941 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45942   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45943   int arg2 ;
45944   int arg3 ;
45945   int arg4 ;
45946   int arg5 ;
45947
45948   arg1 = (Dali::Rect< int > *)jarg1;
45949   arg2 = (int)jarg2;
45950   arg3 = (int)jarg3;
45951   arg4 = (int)jarg4;
45952   arg5 = (int)jarg5;
45953   {
45954     try {
45955       (arg1)->Set(arg2,arg3,arg4,arg5);
45956     } catch (std::out_of_range& e) {
45957       {
45958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45959       };
45960     } catch (std::exception& e) {
45961       {
45962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45963       };
45964     } catch (...) {
45965       {
45966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45967       };
45968     }
45969   }
45970 }
45971
45972
45973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_IsEmpty(void * jarg1) {
45974   unsigned int jresult ;
45975   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45976   bool result;
45977
45978   arg1 = (Dali::Rect< int > *)jarg1;
45979   {
45980     try {
45981       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45982     } catch (std::out_of_range& e) {
45983       {
45984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45985       };
45986     } catch (std::exception& e) {
45987       {
45988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45989       };
45990     } catch (...) {
45991       {
45992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45993       };
45994     }
45995   }
45996   jresult = result;
45997   return jresult;
45998 }
45999
46000
46001 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Left(void * jarg1) {
46002   int jresult ;
46003   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46004   int result;
46005
46006   arg1 = (Dali::Rect< int > *)jarg1;
46007   {
46008     try {
46009       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46010     } catch (std::out_of_range& e) {
46011       {
46012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46013       };
46014     } catch (std::exception& e) {
46015       {
46016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46017       };
46018     } catch (...) {
46019       {
46020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46021       };
46022     }
46023   }
46024   jresult = result;
46025   return jresult;
46026 }
46027
46028
46029 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Right(void * jarg1) {
46030   int jresult ;
46031   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46032   int result;
46033
46034   arg1 = (Dali::Rect< int > *)jarg1;
46035   {
46036     try {
46037       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46038     } catch (std::out_of_range& e) {
46039       {
46040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46041       };
46042     } catch (std::exception& e) {
46043       {
46044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46045       };
46046     } catch (...) {
46047       {
46048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46049       };
46050     }
46051   }
46052   jresult = result;
46053   return jresult;
46054 }
46055
46056
46057 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Top(void * jarg1) {
46058   int jresult ;
46059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46060   int result;
46061
46062   arg1 = (Dali::Rect< int > *)jarg1;
46063   {
46064     try {
46065       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46066     } catch (std::out_of_range& e) {
46067       {
46068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46069       };
46070     } catch (std::exception& e) {
46071       {
46072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46073       };
46074     } catch (...) {
46075       {
46076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46077       };
46078     }
46079   }
46080   jresult = result;
46081   return jresult;
46082 }
46083
46084
46085 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Bottom(void * jarg1) {
46086   int jresult ;
46087   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46088   int result;
46089
46090   arg1 = (Dali::Rect< int > *)jarg1;
46091   {
46092     try {
46093       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46094     } catch (std::out_of_range& e) {
46095       {
46096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46097       };
46098     } catch (std::exception& e) {
46099       {
46100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (...) {
46103       {
46104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46105       };
46106     }
46107   }
46108   jresult = result;
46109   return jresult;
46110 }
46111
46112
46113 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Area(void * jarg1) {
46114   int jresult ;
46115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46116   int result;
46117
46118   arg1 = (Dali::Rect< int > *)jarg1;
46119   {
46120     try {
46121       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46122     } catch (std::out_of_range& e) {
46123       {
46124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46125       };
46126     } catch (std::exception& e) {
46127       {
46128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46129       };
46130     } catch (...) {
46131       {
46132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46133       };
46134     }
46135   }
46136   jresult = result;
46137   return jresult;
46138 }
46139
46140
46141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_Intersects(void * jarg1, void * jarg2) {
46142   unsigned int jresult ;
46143   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46144   Dali::Rect< int > *arg2 = 0 ;
46145   bool result;
46146
46147   arg1 = (Dali::Rect< int > *)jarg1;
46148   arg2 = (Dali::Rect< int > *)jarg2;
46149   if (!arg2) {
46150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46151     return 0;
46152   }
46153   {
46154     try {
46155       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46156     } catch (std::out_of_range& e) {
46157       {
46158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46159       };
46160     } catch (std::exception& e) {
46161       {
46162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46167       };
46168     }
46169   }
46170   jresult = result;
46171   return jresult;
46172 }
46173
46174
46175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_Contains(void * jarg1, void * jarg2) {
46176   unsigned int jresult ;
46177   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46178   Dali::Rect< int > *arg2 = 0 ;
46179   bool result;
46180
46181   arg1 = (Dali::Rect< int > *)jarg1;
46182   arg2 = (Dali::Rect< int > *)jarg2;
46183   if (!arg2) {
46184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46185     return 0;
46186   }
46187   {
46188     try {
46189       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46190     } catch (std::out_of_range& e) {
46191       {
46192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46193       };
46194     } catch (std::exception& e) {
46195       {
46196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46197       };
46198     } catch (...) {
46199       {
46200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46201       };
46202     }
46203   }
46204   jresult = result;
46205   return jresult;
46206 }
46207
46208
46209 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_x_set(void * jarg1, int jarg2) {
46210   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46211   int arg2 ;
46212
46213   arg1 = (Dali::Rect< int > *)jarg1;
46214   arg2 = (int)jarg2;
46215   if (arg1) (arg1)->x = arg2;
46216 }
46217
46218
46219 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_x_get(void * jarg1) {
46220   int jresult ;
46221   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46222   int result;
46223
46224   arg1 = (Dali::Rect< int > *)jarg1;
46225   result = (int) ((arg1)->x);
46226   jresult = result;
46227   return jresult;
46228 }
46229
46230
46231 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_left_set(void * jarg1, int jarg2) {
46232   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46233   int arg2 ;
46234
46235   arg1 = (Dali::Rect< int > *)jarg1;
46236   arg2 = (int)jarg2;
46237   if (arg1) (arg1)->left = arg2;
46238 }
46239
46240
46241 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_left_get(void * jarg1) {
46242   int jresult ;
46243   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46244   int result;
46245
46246   arg1 = (Dali::Rect< int > *)jarg1;
46247   result = (int) ((arg1)->left);
46248   jresult = result;
46249   return jresult;
46250 }
46251
46252
46253 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_y_set(void * jarg1, int jarg2) {
46254   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46255   int arg2 ;
46256
46257   arg1 = (Dali::Rect< int > *)jarg1;
46258   arg2 = (int)jarg2;
46259   if (arg1) (arg1)->y = arg2;
46260 }
46261
46262
46263 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_y_get(void * jarg1) {
46264   int jresult ;
46265   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46266   int result;
46267
46268   arg1 = (Dali::Rect< int > *)jarg1;
46269   result = (int) ((arg1)->y);
46270   jresult = result;
46271   return jresult;
46272 }
46273
46274
46275 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_right_set(void * jarg1, int jarg2) {
46276   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46277   int arg2 ;
46278
46279   arg1 = (Dali::Rect< int > *)jarg1;
46280   arg2 = (int)jarg2;
46281   if (arg1) (arg1)->right = arg2;
46282 }
46283
46284
46285 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_right_get(void * jarg1) {
46286   int jresult ;
46287   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46288   int result;
46289
46290   arg1 = (Dali::Rect< int > *)jarg1;
46291   result = (int) ((arg1)->right);
46292   jresult = result;
46293   return jresult;
46294 }
46295
46296
46297 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_width_set(void * jarg1, int jarg2) {
46298   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46299   int arg2 ;
46300
46301   arg1 = (Dali::Rect< int > *)jarg1;
46302   arg2 = (int)jarg2;
46303   if (arg1) (arg1)->width = arg2;
46304 }
46305
46306
46307 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_width_get(void * jarg1) {
46308   int jresult ;
46309   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46310   int result;
46311
46312   arg1 = (Dali::Rect< int > *)jarg1;
46313   result = (int) ((arg1)->width);
46314   jresult = result;
46315   return jresult;
46316 }
46317
46318
46319 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_bottom_set(void * jarg1, int jarg2) {
46320   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46321   int arg2 ;
46322
46323   arg1 = (Dali::Rect< int > *)jarg1;
46324   arg2 = (int)jarg2;
46325   if (arg1) (arg1)->bottom = arg2;
46326 }
46327
46328
46329 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_bottom_get(void * jarg1) {
46330   int jresult ;
46331   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46332   int result;
46333
46334   arg1 = (Dali::Rect< int > *)jarg1;
46335   result = (int) ((arg1)->bottom);
46336   jresult = result;
46337   return jresult;
46338 }
46339
46340
46341 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_height_set(void * jarg1, int jarg2) {
46342   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46343   int arg2 ;
46344
46345   arg1 = (Dali::Rect< int > *)jarg1;
46346   arg2 = (int)jarg2;
46347   if (arg1) (arg1)->height = arg2;
46348 }
46349
46350
46351 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_height_get(void * jarg1) {
46352   int jresult ;
46353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46354   int result;
46355
46356   arg1 = (Dali::Rect< int > *)jarg1;
46357   result = (int) ((arg1)->height);
46358   jresult = result;
46359   return jresult;
46360 }
46361
46362
46363 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_top_set(void * jarg1, int jarg2) {
46364   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46365   int arg2 ;
46366
46367   arg1 = (Dali::Rect< int > *)jarg1;
46368   arg2 = (int)jarg2;
46369   if (arg1) (arg1)->top = arg2;
46370 }
46371
46372
46373 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_top_get(void * jarg1) {
46374   int jresult ;
46375   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46376   int result;
46377
46378   arg1 = (Dali::Rect< int > *)jarg1;
46379   result = (int) ((arg1)->top);
46380   jresult = result;
46381   return jresult;
46382 }
46383
46384
46385 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectInteger(void * jarg1) {
46386   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46387
46388   arg1 = (Dali::Rect< int > *)jarg1;
46389   {
46390     try {
46391       delete arg1;
46392     } catch (std::out_of_range& e) {
46393       {
46394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46395       };
46396     } catch (std::exception& e) {
46397       {
46398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46399       };
46400     } catch (...) {
46401       {
46402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46403       };
46404     }
46405   }
46406 }
46407
46408
46409 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_0() {
46410   void * jresult ;
46411   Dali::Rect< unsigned int > *result = 0 ;
46412
46413   {
46414     try {
46415       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >();
46416     } catch (std::out_of_range& e) {
46417       {
46418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46419       };
46420     } catch (std::exception& e) {
46421       {
46422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46423       };
46424     } catch (...) {
46425       {
46426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46427       };
46428     }
46429   }
46430   jresult = (void *)result;
46431   return jresult;
46432 }
46433
46434
46435 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46436   void * jresult ;
46437   unsigned int arg1 ;
46438   unsigned int arg2 ;
46439   unsigned int arg3 ;
46440   unsigned int arg4 ;
46441   Dali::Rect< unsigned int > *result = 0 ;
46442
46443   arg1 = (unsigned int)jarg1;
46444   arg2 = (unsigned int)jarg2;
46445   arg3 = (unsigned int)jarg3;
46446   arg4 = (unsigned int)jarg4;
46447   {
46448     try {
46449       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >(arg1,arg2,arg3,arg4);
46450     } catch (std::out_of_range& e) {
46451       {
46452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46453       };
46454     } catch (std::exception& e) {
46455       {
46456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46457       };
46458     } catch (...) {
46459       {
46460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46461       };
46462     }
46463   }
46464   jresult = (void *)result;
46465   return jresult;
46466 }
46467
46468
46469 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_2(void * jarg1) {
46470   void * jresult ;
46471   Dali::Rect< unsigned int > *arg1 = 0 ;
46472   Dali::Rect< unsigned int > *result = 0 ;
46473
46474   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46475   if (!arg1) {
46476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46477     return 0;
46478   }
46479   {
46480     try {
46481       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >((Dali::Rect< unsigned int > const &)*arg1);
46482     } catch (std::out_of_range& e) {
46483       {
46484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46485       };
46486     } catch (std::exception& e) {
46487       {
46488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46489       };
46490     } catch (...) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46493       };
46494     }
46495   }
46496   jresult = (void *)result;
46497   return jresult;
46498 }
46499
46500
46501 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Assign(void * jarg1, void * jarg2) {
46502   void * jresult ;
46503   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46504   Dali::Rect< unsigned int > *arg2 = 0 ;
46505   Dali::Rect< unsigned int > *result = 0 ;
46506
46507   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46508   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46509   if (!arg2) {
46510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46511     return 0;
46512   }
46513   {
46514     try {
46515       result = (Dali::Rect< unsigned int > *) &(arg1)->operator =((Dali::Rect< unsigned int > const &)*arg2);
46516     } catch (std::out_of_range& e) {
46517       {
46518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46519       };
46520     } catch (std::exception& e) {
46521       {
46522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46523       };
46524     } catch (...) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46527       };
46528     }
46529   }
46530   jresult = (void *)result;
46531   return jresult;
46532 }
46533
46534
46535 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Set(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
46536   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46537   unsigned int arg2 ;
46538   unsigned int arg3 ;
46539   unsigned int arg4 ;
46540   unsigned int arg5 ;
46541
46542   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46543   arg2 = (unsigned int)jarg2;
46544   arg3 = (unsigned int)jarg3;
46545   arg4 = (unsigned int)jarg4;
46546   arg5 = (unsigned int)jarg5;
46547   {
46548     try {
46549       (arg1)->Set(arg2,arg3,arg4,arg5);
46550     } catch (std::out_of_range& e) {
46551       {
46552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46553       };
46554     } catch (std::exception& e) {
46555       {
46556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46557       };
46558     } catch (...) {
46559       {
46560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46561       };
46562     }
46563   }
46564 }
46565
46566
46567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_IsEmpty(void * jarg1) {
46568   unsigned int jresult ;
46569   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46570   bool result;
46571
46572   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46573   {
46574     try {
46575       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->IsEmpty();
46576     } catch (std::out_of_range& e) {
46577       {
46578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46579       };
46580     } catch (std::exception& e) {
46581       {
46582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46583       };
46584     } catch (...) {
46585       {
46586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46587       };
46588     }
46589   }
46590   jresult = result;
46591   return jresult;
46592 }
46593
46594
46595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Left(void * jarg1) {
46596   unsigned int jresult ;
46597   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46598   unsigned int result;
46599
46600   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46601   {
46602     try {
46603       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Left();
46604     } catch (std::out_of_range& e) {
46605       {
46606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (std::exception& e) {
46609       {
46610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46615       };
46616     }
46617   }
46618   jresult = result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Right(void * jarg1) {
46624   unsigned int jresult ;
46625   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46626   unsigned int result;
46627
46628   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46629   {
46630     try {
46631       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Right();
46632     } catch (std::out_of_range& e) {
46633       {
46634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46635       };
46636     } catch (std::exception& e) {
46637       {
46638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46639       };
46640     } catch (...) {
46641       {
46642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46643       };
46644     }
46645   }
46646   jresult = result;
46647   return jresult;
46648 }
46649
46650
46651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Top(void * jarg1) {
46652   unsigned int jresult ;
46653   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46654   unsigned int result;
46655
46656   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46657   {
46658     try {
46659       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Top();
46660     } catch (std::out_of_range& e) {
46661       {
46662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46663       };
46664     } catch (std::exception& e) {
46665       {
46666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (...) {
46669       {
46670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46671       };
46672     }
46673   }
46674   jresult = result;
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Bottom(void * jarg1) {
46680   unsigned int jresult ;
46681   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46682   unsigned int result;
46683
46684   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46685   {
46686     try {
46687       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Bottom();
46688     } catch (std::out_of_range& e) {
46689       {
46690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46691       };
46692     } catch (std::exception& e) {
46693       {
46694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46695       };
46696     } catch (...) {
46697       {
46698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46699       };
46700     }
46701   }
46702   jresult = result;
46703   return jresult;
46704 }
46705
46706
46707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Area(void * jarg1) {
46708   unsigned int jresult ;
46709   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46710   unsigned int result;
46711
46712   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46713   {
46714     try {
46715       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Area();
46716     } catch (std::out_of_range& e) {
46717       {
46718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46719       };
46720     } catch (std::exception& e) {
46721       {
46722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46723       };
46724     } catch (...) {
46725       {
46726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46727       };
46728     }
46729   }
46730   jresult = result;
46731   return jresult;
46732 }
46733
46734
46735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Intersects(void * jarg1, void * jarg2) {
46736   unsigned int jresult ;
46737   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46738   Dali::Rect< unsigned int > *arg2 = 0 ;
46739   bool result;
46740
46741   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46742   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46743   if (!arg2) {
46744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46745     return 0;
46746   }
46747   {
46748     try {
46749       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Intersects((Dali::Rect< unsigned int > const &)*arg2);
46750     } catch (std::out_of_range& e) {
46751       {
46752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46753       };
46754     } catch (std::exception& e) {
46755       {
46756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46757       };
46758     } catch (...) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46761       };
46762     }
46763   }
46764   jresult = result;
46765   return jresult;
46766 }
46767
46768
46769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Contains(void * jarg1, void * jarg2) {
46770   unsigned int jresult ;
46771   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46772   Dali::Rect< unsigned int > *arg2 = 0 ;
46773   bool result;
46774
46775   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46776   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46777   if (!arg2) {
46778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46779     return 0;
46780   }
46781   {
46782     try {
46783       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Contains((Dali::Rect< unsigned int > const &)*arg2);
46784     } catch (std::out_of_range& e) {
46785       {
46786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46787       };
46788     } catch (std::exception& e) {
46789       {
46790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46791       };
46792     } catch (...) {
46793       {
46794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46795       };
46796     }
46797   }
46798   jresult = result;
46799   return jresult;
46800 }
46801
46802
46803 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_x_set(void * jarg1, unsigned int jarg2) {
46804   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46805   unsigned int arg2 ;
46806
46807   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46808   arg2 = (unsigned int)jarg2;
46809   if (arg1) (arg1)->x = arg2;
46810 }
46811
46812
46813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_x_get(void * jarg1) {
46814   unsigned int jresult ;
46815   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46816   unsigned int result;
46817
46818   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46819   result = (unsigned int) ((arg1)->x);
46820   jresult = result;
46821   return jresult;
46822 }
46823
46824
46825 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_left_set(void * jarg1, unsigned int jarg2) {
46826   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46827   unsigned int arg2 ;
46828
46829   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46830   arg2 = (unsigned int)jarg2;
46831   if (arg1) (arg1)->left = arg2;
46832 }
46833
46834
46835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_left_get(void * jarg1) {
46836   unsigned int jresult ;
46837   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46838   unsigned int result;
46839
46840   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46841   result = (unsigned int) ((arg1)->left);
46842   jresult = result;
46843   return jresult;
46844 }
46845
46846
46847 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_y_set(void * jarg1, unsigned int jarg2) {
46848   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46849   unsigned int arg2 ;
46850
46851   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46852   arg2 = (unsigned int)jarg2;
46853   if (arg1) (arg1)->y = arg2;
46854 }
46855
46856
46857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_y_get(void * jarg1) {
46858   unsigned int jresult ;
46859   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46860   unsigned int result;
46861
46862   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46863   result = (unsigned int) ((arg1)->y);
46864   jresult = result;
46865   return jresult;
46866 }
46867
46868
46869 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_right_set(void * jarg1, unsigned int jarg2) {
46870   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46871   unsigned int arg2 ;
46872
46873   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46874   arg2 = (unsigned int)jarg2;
46875   if (arg1) (arg1)->right = arg2;
46876 }
46877
46878
46879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_right_get(void * jarg1) {
46880   unsigned int jresult ;
46881   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46882   unsigned int result;
46883
46884   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46885   result = (unsigned int) ((arg1)->right);
46886   jresult = result;
46887   return jresult;
46888 }
46889
46890
46891 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_width_set(void * jarg1, unsigned int jarg2) {
46892   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46893   unsigned int arg2 ;
46894
46895   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46896   arg2 = (unsigned int)jarg2;
46897   if (arg1) (arg1)->width = arg2;
46898 }
46899
46900
46901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_width_get(void * jarg1) {
46902   unsigned int jresult ;
46903   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46904   unsigned int result;
46905
46906   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46907   result = (unsigned int) ((arg1)->width);
46908   jresult = result;
46909   return jresult;
46910 }
46911
46912
46913 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_bottom_set(void * jarg1, unsigned int jarg2) {
46914   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46915   unsigned int arg2 ;
46916
46917   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46918   arg2 = (unsigned int)jarg2;
46919   if (arg1) (arg1)->bottom = arg2;
46920 }
46921
46922
46923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_bottom_get(void * jarg1) {
46924   unsigned int jresult ;
46925   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46926   unsigned int result;
46927
46928   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46929   result = (unsigned int) ((arg1)->bottom);
46930   jresult = result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_height_set(void * jarg1, unsigned int jarg2) {
46936   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46937   unsigned int arg2 ;
46938
46939   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46940   arg2 = (unsigned int)jarg2;
46941   if (arg1) (arg1)->height = arg2;
46942 }
46943
46944
46945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_height_get(void * jarg1) {
46946   unsigned int jresult ;
46947   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46948   unsigned int result;
46949
46950   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46951   result = (unsigned int) ((arg1)->height);
46952   jresult = result;
46953   return jresult;
46954 }
46955
46956
46957 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_top_set(void * jarg1, unsigned int jarg2) {
46958   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46959   unsigned int arg2 ;
46960
46961   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46962   arg2 = (unsigned int)jarg2;
46963   if (arg1) (arg1)->top = arg2;
46964 }
46965
46966
46967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_top_get(void * jarg1) {
46968   unsigned int jresult ;
46969   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46970   unsigned int result;
46971
46972   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46973   result = (unsigned int) ((arg1)->top);
46974   jresult = result;
46975   return jresult;
46976 }
46977
46978
46979 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectUnsignedInteger(void * jarg1) {
46980   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46981
46982   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46983   {
46984     try {
46985       delete arg1;
46986     } catch (std::out_of_range& e) {
46987       {
46988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46989       };
46990     } catch (std::exception& e) {
46991       {
46992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46993       };
46994     } catch (...) {
46995       {
46996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46997       };
46998     }
46999   }
47000 }
47001
47002
47003 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_0() {
47004   void * jresult ;
47005   Dali::Rect< float > *result = 0 ;
47006
47007   {
47008     try {
47009       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47010     } catch (std::out_of_range& e) {
47011       {
47012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47013       };
47014     } catch (std::exception& e) {
47015       {
47016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47017       };
47018     } catch (...) {
47019       {
47020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47021       };
47022     }
47023   }
47024   jresult = (void *)result;
47025   return jresult;
47026 }
47027
47028
47029 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47030   void * jresult ;
47031   float arg1 ;
47032   float arg2 ;
47033   float arg3 ;
47034   float arg4 ;
47035   Dali::Rect< float > *result = 0 ;
47036
47037   arg1 = (float)jarg1;
47038   arg2 = (float)jarg2;
47039   arg3 = (float)jarg3;
47040   arg4 = (float)jarg4;
47041   {
47042     try {
47043       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47044     } catch (std::out_of_range& e) {
47045       {
47046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47047       };
47048     } catch (std::exception& e) {
47049       {
47050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47051       };
47052     } catch (...) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47055       };
47056     }
47057   }
47058   jresult = (void *)result;
47059   return jresult;
47060 }
47061
47062
47063 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_2(void * jarg1) {
47064   void * jresult ;
47065   Dali::Rect< float > *arg1 = 0 ;
47066   Dali::Rect< float > *result = 0 ;
47067
47068   arg1 = (Dali::Rect< float > *)jarg1;
47069   if (!arg1) {
47070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47071     return 0;
47072   }
47073   {
47074     try {
47075       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47076     } catch (std::out_of_range& e) {
47077       {
47078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (std::exception& e) {
47081       {
47082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47083       };
47084     } catch (...) {
47085       {
47086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47087       };
47088     }
47089   }
47090   jresult = (void *)result;
47091   return jresult;
47092 }
47093
47094
47095 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectFloat_Assign(void * jarg1, void * jarg2) {
47096   void * jresult ;
47097   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47098   Dali::Rect< float > *arg2 = 0 ;
47099   Dali::Rect< float > *result = 0 ;
47100
47101   arg1 = (Dali::Rect< float > *)jarg1;
47102   arg2 = (Dali::Rect< float > *)jarg2;
47103   if (!arg2) {
47104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47105     return 0;
47106   }
47107   {
47108     try {
47109       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47110     } catch (std::out_of_range& e) {
47111       {
47112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47113       };
47114     } catch (std::exception& e) {
47115       {
47116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47117       };
47118     } catch (...) {
47119       {
47120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47121       };
47122     }
47123   }
47124   jresult = (void *)result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47130   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47131   float arg2 ;
47132   float arg3 ;
47133   float arg4 ;
47134   float arg5 ;
47135
47136   arg1 = (Dali::Rect< float > *)jarg1;
47137   arg2 = (float)jarg2;
47138   arg3 = (float)jarg3;
47139   arg4 = (float)jarg4;
47140   arg5 = (float)jarg5;
47141   {
47142     try {
47143       (arg1)->Set(arg2,arg3,arg4,arg5);
47144     } catch (std::out_of_range& e) {
47145       {
47146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47147       };
47148     } catch (std::exception& e) {
47149       {
47150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47151       };
47152     } catch (...) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47155       };
47156     }
47157   }
47158 }
47159
47160
47161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_IsEmpty(void * jarg1) {
47162   unsigned int jresult ;
47163   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47164   bool result;
47165
47166   arg1 = (Dali::Rect< float > *)jarg1;
47167   {
47168     try {
47169       result = (bool)((Dali::Rect< float > const *)arg1)->IsEmpty();
47170     } catch (std::out_of_range& e) {
47171       {
47172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47173       };
47174     } catch (std::exception& e) {
47175       {
47176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47177       };
47178     } catch (...) {
47179       {
47180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47181       };
47182     }
47183   }
47184   jresult = result;
47185   return jresult;
47186 }
47187
47188
47189 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Left(void * jarg1) {
47190   float jresult ;
47191   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47192   float result;
47193
47194   arg1 = (Dali::Rect< float > *)jarg1;
47195   {
47196     try {
47197       result = (float)((Dali::Rect< float > const *)arg1)->Left();
47198     } catch (std::out_of_range& e) {
47199       {
47200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47201       };
47202     } catch (std::exception& e) {
47203       {
47204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47205       };
47206     } catch (...) {
47207       {
47208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47209       };
47210     }
47211   }
47212   jresult = result;
47213   return jresult;
47214 }
47215
47216
47217 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Right(void * jarg1) {
47218   float jresult ;
47219   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47220   float result;
47221
47222   arg1 = (Dali::Rect< float > *)jarg1;
47223   {
47224     try {
47225       result = (float)((Dali::Rect< float > const *)arg1)->Right();
47226     } catch (std::out_of_range& e) {
47227       {
47228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47229       };
47230     } catch (std::exception& e) {
47231       {
47232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47233       };
47234     } catch (...) {
47235       {
47236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47237       };
47238     }
47239   }
47240   jresult = result;
47241   return jresult;
47242 }
47243
47244
47245 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Top(void * jarg1) {
47246   float jresult ;
47247   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47248   float result;
47249
47250   arg1 = (Dali::Rect< float > *)jarg1;
47251   {
47252     try {
47253       result = (float)((Dali::Rect< float > const *)arg1)->Top();
47254     } catch (std::out_of_range& e) {
47255       {
47256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47257       };
47258     } catch (std::exception& e) {
47259       {
47260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47261       };
47262     } catch (...) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47265       };
47266     }
47267   }
47268   jresult = result;
47269   return jresult;
47270 }
47271
47272
47273 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Bottom(void * jarg1) {
47274   float jresult ;
47275   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47276   float result;
47277
47278   arg1 = (Dali::Rect< float > *)jarg1;
47279   {
47280     try {
47281       result = (float)((Dali::Rect< float > const *)arg1)->Bottom();
47282     } catch (std::out_of_range& e) {
47283       {
47284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47285       };
47286     } catch (std::exception& e) {
47287       {
47288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47289       };
47290     } catch (...) {
47291       {
47292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47293       };
47294     }
47295   }
47296   jresult = result;
47297   return jresult;
47298 }
47299
47300
47301 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Area(void * jarg1) {
47302   float jresult ;
47303   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47304   float result;
47305
47306   arg1 = (Dali::Rect< float > *)jarg1;
47307   {
47308     try {
47309       result = (float)((Dali::Rect< float > const *)arg1)->Area();
47310     } catch (std::out_of_range& e) {
47311       {
47312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47313       };
47314     } catch (std::exception& e) {
47315       {
47316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (...) {
47319       {
47320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47321       };
47322     }
47323   }
47324   jresult = result;
47325   return jresult;
47326 }
47327
47328
47329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_Intersects(void * jarg1, void * jarg2) {
47330   unsigned int jresult ;
47331   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47332   Dali::Rect< float > *arg2 = 0 ;
47333   bool result;
47334
47335   arg1 = (Dali::Rect< float > *)jarg1;
47336   arg2 = (Dali::Rect< float > *)jarg2;
47337   if (!arg2) {
47338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47339     return 0;
47340   }
47341   {
47342     try {
47343       result = (bool)((Dali::Rect< float > const *)arg1)->Intersects((Dali::Rect< float > const &)*arg2);
47344     } catch (std::out_of_range& e) {
47345       {
47346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47347       };
47348     } catch (std::exception& e) {
47349       {
47350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47351       };
47352     } catch (...) {
47353       {
47354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47355       };
47356     }
47357   }
47358   jresult = result;
47359   return jresult;
47360 }
47361
47362
47363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_Contains(void * jarg1, void * jarg2) {
47364   unsigned int jresult ;
47365   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47366   Dali::Rect< float > *arg2 = 0 ;
47367   bool result;
47368
47369   arg1 = (Dali::Rect< float > *)jarg1;
47370   arg2 = (Dali::Rect< float > *)jarg2;
47371   if (!arg2) {
47372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47373     return 0;
47374   }
47375   {
47376     try {
47377       result = (bool)((Dali::Rect< float > const *)arg1)->Contains((Dali::Rect< float > const &)*arg2);
47378     } catch (std::out_of_range& e) {
47379       {
47380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47381       };
47382     } catch (std::exception& e) {
47383       {
47384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47385       };
47386     } catch (...) {
47387       {
47388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47389       };
47390     }
47391   }
47392   jresult = result;
47393   return jresult;
47394 }
47395
47396
47397 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_x_set(void * jarg1, float jarg2) {
47398   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47399   float arg2 ;
47400
47401   arg1 = (Dali::Rect< float > *)jarg1;
47402   arg2 = (float)jarg2;
47403   if (arg1) (arg1)->x = arg2;
47404 }
47405
47406
47407 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_x_get(void * jarg1) {
47408   float jresult ;
47409   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47410   float result;
47411
47412   arg1 = (Dali::Rect< float > *)jarg1;
47413   result = (float) ((arg1)->x);
47414   jresult = result;
47415   return jresult;
47416 }
47417
47418
47419 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_left_set(void * jarg1, float jarg2) {
47420   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47421   float arg2 ;
47422
47423   arg1 = (Dali::Rect< float > *)jarg1;
47424   arg2 = (float)jarg2;
47425   if (arg1) (arg1)->left = arg2;
47426 }
47427
47428
47429 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_left_get(void * jarg1) {
47430   float jresult ;
47431   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47432   float result;
47433
47434   arg1 = (Dali::Rect< float > *)jarg1;
47435   result = (float) ((arg1)->left);
47436   jresult = result;
47437   return jresult;
47438 }
47439
47440
47441 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_y_set(void * jarg1, float jarg2) {
47442   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47443   float arg2 ;
47444
47445   arg1 = (Dali::Rect< float > *)jarg1;
47446   arg2 = (float)jarg2;
47447   if (arg1) (arg1)->y = arg2;
47448 }
47449
47450
47451 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_y_get(void * jarg1) {
47452   float jresult ;
47453   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47454   float result;
47455
47456   arg1 = (Dali::Rect< float > *)jarg1;
47457   result = (float) ((arg1)->y);
47458   jresult = result;
47459   return jresult;
47460 }
47461
47462
47463 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_right_set(void * jarg1, float jarg2) {
47464   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47465   float arg2 ;
47466
47467   arg1 = (Dali::Rect< float > *)jarg1;
47468   arg2 = (float)jarg2;
47469   if (arg1) (arg1)->right = arg2;
47470 }
47471
47472
47473 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_right_get(void * jarg1) {
47474   float jresult ;
47475   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47476   float result;
47477
47478   arg1 = (Dali::Rect< float > *)jarg1;
47479   result = (float) ((arg1)->right);
47480   jresult = result;
47481   return jresult;
47482 }
47483
47484
47485 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_width_set(void * jarg1, float jarg2) {
47486   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47487   float arg2 ;
47488
47489   arg1 = (Dali::Rect< float > *)jarg1;
47490   arg2 = (float)jarg2;
47491   if (arg1) (arg1)->width = arg2;
47492 }
47493
47494
47495 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_width_get(void * jarg1) {
47496   float jresult ;
47497   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47498   float result;
47499
47500   arg1 = (Dali::Rect< float > *)jarg1;
47501   result = (float) ((arg1)->width);
47502   jresult = result;
47503   return jresult;
47504 }
47505
47506
47507 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_bottom_set(void * jarg1, float jarg2) {
47508   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47509   float arg2 ;
47510
47511   arg1 = (Dali::Rect< float > *)jarg1;
47512   arg2 = (float)jarg2;
47513   if (arg1) (arg1)->bottom = arg2;
47514 }
47515
47516
47517 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_bottom_get(void * jarg1) {
47518   float jresult ;
47519   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47520   float result;
47521
47522   arg1 = (Dali::Rect< float > *)jarg1;
47523   result = (float) ((arg1)->bottom);
47524   jresult = result;
47525   return jresult;
47526 }
47527
47528
47529 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_height_set(void * jarg1, float jarg2) {
47530   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47531   float arg2 ;
47532
47533   arg1 = (Dali::Rect< float > *)jarg1;
47534   arg2 = (float)jarg2;
47535   if (arg1) (arg1)->height = arg2;
47536 }
47537
47538
47539 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_height_get(void * jarg1) {
47540   float jresult ;
47541   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47542   float result;
47543
47544   arg1 = (Dali::Rect< float > *)jarg1;
47545   result = (float) ((arg1)->height);
47546   jresult = result;
47547   return jresult;
47548 }
47549
47550
47551 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_top_set(void * jarg1, float jarg2) {
47552   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47553   float arg2 ;
47554
47555   arg1 = (Dali::Rect< float > *)jarg1;
47556   arg2 = (float)jarg2;
47557   if (arg1) (arg1)->top = arg2;
47558 }
47559
47560
47561 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_top_get(void * jarg1) {
47562   float jresult ;
47563   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47564   float result;
47565
47566   arg1 = (Dali::Rect< float > *)jarg1;
47567   result = (float) ((arg1)->top);
47568   jresult = result;
47569   return jresult;
47570 }
47571
47572
47573 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectFloat(void * jarg1) {
47574   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47575
47576   arg1 = (Dali::Rect< float > *)jarg1;
47577   {
47578     try {
47579       delete arg1;
47580     } catch (std::out_of_range& e) {
47581       {
47582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47583       };
47584     } catch (std::exception& e) {
47585       {
47586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47587       };
47588     } catch (...) {
47589       {
47590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47591       };
47592     }
47593   }
47594 }
47595
47596
47597 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorInteger_BaseType_get() {
47598   int jresult ;
47599   int result;
47600
47601   result = (int)Dali::Vector< int >::BaseType;
47602   jresult = (int)result;
47603   return jresult;
47604 }
47605
47606
47607 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorInteger__SWIG_0() {
47608   void * jresult ;
47609   Dali::Vector< int > *result = 0 ;
47610
47611   {
47612     try {
47613       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47614     } catch (std::out_of_range& e) {
47615       {
47616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47617       };
47618     } catch (std::exception& e) {
47619       {
47620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47621       };
47622     } catch (...) {
47623       {
47624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47625       };
47626     }
47627   }
47628   jresult = (void *)result;
47629   return jresult;
47630 }
47631
47632
47633 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorInteger(void * jarg1) {
47634   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47635
47636   arg1 = (Dali::Vector< int > *)jarg1;
47637   {
47638     try {
47639       delete arg1;
47640     } catch (std::out_of_range& e) {
47641       {
47642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47643       };
47644     } catch (std::exception& e) {
47645       {
47646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47647       };
47648     } catch (...) {
47649       {
47650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47651       };
47652     }
47653   }
47654 }
47655
47656
47657 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorInteger__SWIG_1(void * jarg1) {
47658   void * jresult ;
47659   Dali::Vector< int > *arg1 = 0 ;
47660   Dali::Vector< int > *result = 0 ;
47661
47662   arg1 = (Dali::Vector< int > *)jarg1;
47663   if (!arg1) {
47664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47665     return 0;
47666   }
47667   {
47668     try {
47669       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47670     } catch (std::out_of_range& e) {
47671       {
47672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47673       };
47674     } catch (std::exception& e) {
47675       {
47676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47677       };
47678     } catch (...) {
47679       {
47680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47681       };
47682     }
47683   }
47684   jresult = (void *)result;
47685   return jresult;
47686 }
47687
47688
47689 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Assign(void * jarg1, void * jarg2) {
47690   void * jresult ;
47691   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47692   Dali::Vector< int > *arg2 = 0 ;
47693   Dali::Vector< int > *result = 0 ;
47694
47695   arg1 = (Dali::Vector< int > *)jarg1;
47696   arg2 = (Dali::Vector< int > *)jarg2;
47697   if (!arg2) {
47698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47699     return 0;
47700   }
47701   {
47702     try {
47703       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47704     } catch (std::out_of_range& e) {
47705       {
47706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47707       };
47708     } catch (std::exception& e) {
47709       {
47710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47711       };
47712     } catch (...) {
47713       {
47714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47715       };
47716     }
47717   }
47718   jresult = (void *)result;
47719   return jresult;
47720 }
47721
47722
47723 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Begin(void * jarg1) {
47724   void * jresult ;
47725   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47726   Dali::Vector< int >::Iterator result;
47727
47728   arg1 = (Dali::Vector< int > *)jarg1;
47729   {
47730     try {
47731       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47732     } catch (std::out_of_range& e) {
47733       {
47734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47735       };
47736     } catch (std::exception& e) {
47737       {
47738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47739       };
47740     } catch (...) {
47741       {
47742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47743       };
47744     }
47745   }
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_End(void * jarg1) {
47752   void * jresult ;
47753   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47754   Dali::Vector< int >::Iterator result;
47755
47756   arg1 = (Dali::Vector< int > *)jarg1;
47757   {
47758     try {
47759       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47760     } catch (std::out_of_range& e) {
47761       {
47762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47763       };
47764     } catch (std::exception& e) {
47765       {
47766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47767       };
47768     } catch (...) {
47769       {
47770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47771       };
47772     }
47773   }
47774   jresult = (void *)result;
47775   return jresult;
47776 }
47777
47778
47779 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47780   void * jresult ;
47781   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47782   Dali::Vector< int >::SizeType arg2 ;
47783   Dali::Vector< int >::ItemType *result = 0 ;
47784
47785   arg1 = (Dali::Vector< int > *)jarg1;
47786   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47787   {
47788     try {
47789       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47790     } catch (std::out_of_range& e) {
47791       {
47792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47793       };
47794     } catch (std::exception& e) {
47795       {
47796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47797       };
47798     } catch (...) {
47799       {
47800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47801       };
47802     }
47803   }
47804   jresult = (void *)result;
47805   return jresult;
47806 }
47807
47808
47809 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_PushBack(void * jarg1, int jarg2) {
47810   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47811   Dali::Vector< int >::ItemType *arg2 = 0 ;
47812   Dali::Vector< int >::ItemType temp2 ;
47813
47814   arg1 = (Dali::Vector< int > *)jarg1;
47815   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47816   arg2 = &temp2;
47817   {
47818     try {
47819       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47827       };
47828     } catch (...) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47831       };
47832     }
47833   }
47834 }
47835
47836
47837 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47838   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47839   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47840   Dali::Vector< int >::ItemType *arg3 = 0 ;
47841   Dali::Vector< int >::ItemType temp3 ;
47842
47843   arg1 = (Dali::Vector< int > *)jarg1;
47844   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47845   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47846   arg3 = &temp3;
47847   {
47848     try {
47849       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47850     } catch (std::out_of_range& e) {
47851       {
47852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47853       };
47854     } catch (std::exception& e) {
47855       {
47856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47857       };
47858     } catch (...) {
47859       {
47860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47861       };
47862     }
47863   }
47864 }
47865
47866
47867 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47868   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47869   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47870   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47871   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47872
47873   arg1 = (Dali::Vector< int > *)jarg1;
47874   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47875   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47876   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47877   {
47878     try {
47879       (arg1)->Insert(arg2,arg3,arg4);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47891       };
47892     }
47893   }
47894 }
47895
47896
47897 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47898   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47899   Dali::Vector< int >::SizeType arg2 ;
47900
47901   arg1 = (Dali::Vector< int > *)jarg1;
47902   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47903   {
47904     try {
47905       (arg1)->Reserve(arg2);
47906     } catch (std::out_of_range& e) {
47907       {
47908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47909       };
47910     } catch (std::exception& e) {
47911       {
47912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47913       };
47914     } catch (...) {
47915       {
47916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47917       };
47918     }
47919   }
47920 }
47921
47922
47923 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47924   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47925   Dali::Vector< int >::SizeType arg2 ;
47926
47927   arg1 = (Dali::Vector< int > *)jarg1;
47928   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47929   {
47930     try {
47931       (arg1)->Resize(arg2);
47932     } catch (std::out_of_range& e) {
47933       {
47934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47935       };
47936     } catch (std::exception& e) {
47937       {
47938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47939       };
47940     } catch (...) {
47941       {
47942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47943       };
47944     }
47945   }
47946 }
47947
47948
47949 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47950   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47951   Dali::Vector< int >::SizeType arg2 ;
47952   Dali::Vector< int >::ItemType *arg3 = 0 ;
47953   Dali::Vector< int >::ItemType temp3 ;
47954
47955   arg1 = (Dali::Vector< int > *)jarg1;
47956   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47957   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47958   arg3 = &temp3;
47959   {
47960     try {
47961       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47962     } catch (std::out_of_range& e) {
47963       {
47964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (std::exception& e) {
47967       {
47968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47969       };
47970     } catch (...) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47973       };
47974     }
47975   }
47976 }
47977
47978
47979 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
47980   void * jresult ;
47981   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47982   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47983   Dali::Vector< int >::Iterator result;
47984
47985   arg1 = (Dali::Vector< int > *)jarg1;
47986   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47987   {
47988     try {
47989       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
47990     } catch (std::out_of_range& e) {
47991       {
47992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47993       };
47994     } catch (std::exception& e) {
47995       {
47996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47997       };
47998     } catch (...) {
47999       {
48000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48001       };
48002     }
48003   }
48004   jresult = (void *)result;
48005   return jresult;
48006 }
48007
48008
48009 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48010   void * jresult ;
48011   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48012   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48013   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48014   Dali::Vector< int >::Iterator result;
48015
48016   arg1 = (Dali::Vector< int > *)jarg1;
48017   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48018   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48019   {
48020     try {
48021       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48022     } catch (std::out_of_range& e) {
48023       {
48024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48025       };
48026     } catch (std::exception& e) {
48027       {
48028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48029       };
48030     } catch (...) {
48031       {
48032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48033       };
48034     }
48035   }
48036   jresult = (void *)result;
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Remove(void * jarg1, void * jarg2) {
48042   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48043   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48044
48045   arg1 = (Dali::Vector< int > *)jarg1;
48046   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48047   {
48048     try {
48049       (arg1)->Remove(arg2);
48050     } catch (std::out_of_range& e) {
48051       {
48052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48053       };
48054     } catch (std::exception& e) {
48055       {
48056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48057       };
48058     } catch (...) {
48059       {
48060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48061       };
48062     }
48063   }
48064 }
48065
48066
48067 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Swap(void * jarg1, void * jarg2) {
48068   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48069   Dali::Vector< int > *arg2 = 0 ;
48070
48071   arg1 = (Dali::Vector< int > *)jarg1;
48072   arg2 = (Dali::Vector< int > *)jarg2;
48073   if (!arg2) {
48074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48075     return ;
48076   }
48077   {
48078     try {
48079       (arg1)->Swap(*arg2);
48080     } catch (std::out_of_range& e) {
48081       {
48082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48083       };
48084     } catch (std::exception& e) {
48085       {
48086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48087       };
48088     } catch (...) {
48089       {
48090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48091       };
48092     }
48093   }
48094 }
48095
48096
48097 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Clear(void * jarg1) {
48098   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48099
48100   arg1 = (Dali::Vector< int > *)jarg1;
48101   {
48102     try {
48103       (arg1)->Clear();
48104     } catch (std::out_of_range& e) {
48105       {
48106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48107       };
48108     } catch (std::exception& e) {
48109       {
48110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48111       };
48112     } catch (...) {
48113       {
48114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48115       };
48116     }
48117   }
48118 }
48119
48120
48121 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Release(void * jarg1) {
48122   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48123
48124   arg1 = (Dali::Vector< int > *)jarg1;
48125   {
48126     try {
48127       (arg1)->Release();
48128     } catch (std::out_of_range& e) {
48129       {
48130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48131       };
48132     } catch (std::exception& e) {
48133       {
48134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48135       };
48136     } catch (...) {
48137       {
48138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48139       };
48140     }
48141   }
48142 }
48143
48144
48145 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorFloat_BaseType_get() {
48146   int jresult ;
48147   int result;
48148
48149   result = (int)Dali::Vector< float >::BaseType;
48150   jresult = (int)result;
48151   return jresult;
48152 }
48153
48154
48155 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorFloat__SWIG_0() {
48156   void * jresult ;
48157   Dali::Vector< float > *result = 0 ;
48158
48159   {
48160     try {
48161       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48162     } catch (std::out_of_range& e) {
48163       {
48164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48165       };
48166     } catch (std::exception& e) {
48167       {
48168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48169       };
48170     } catch (...) {
48171       {
48172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48173       };
48174     }
48175   }
48176   jresult = (void *)result;
48177   return jresult;
48178 }
48179
48180
48181 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorFloat(void * jarg1) {
48182   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48183
48184   arg1 = (Dali::Vector< float > *)jarg1;
48185   {
48186     try {
48187       delete arg1;
48188     } catch (std::out_of_range& e) {
48189       {
48190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48191       };
48192     } catch (std::exception& e) {
48193       {
48194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48195       };
48196     } catch (...) {
48197       {
48198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48199       };
48200     }
48201   }
48202 }
48203
48204
48205 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorFloat__SWIG_1(void * jarg1) {
48206   void * jresult ;
48207   Dali::Vector< float > *arg1 = 0 ;
48208   Dali::Vector< float > *result = 0 ;
48209
48210   arg1 = (Dali::Vector< float > *)jarg1;
48211   if (!arg1) {
48212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48213     return 0;
48214   }
48215   {
48216     try {
48217       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (...) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48229       };
48230     }
48231   }
48232   jresult = (void *)result;
48233   return jresult;
48234 }
48235
48236
48237 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Assign(void * jarg1, void * jarg2) {
48238   void * jresult ;
48239   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48240   Dali::Vector< float > *arg2 = 0 ;
48241   Dali::Vector< float > *result = 0 ;
48242
48243   arg1 = (Dali::Vector< float > *)jarg1;
48244   arg2 = (Dali::Vector< float > *)jarg2;
48245   if (!arg2) {
48246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48247     return 0;
48248   }
48249   {
48250     try {
48251       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48252     } catch (std::out_of_range& e) {
48253       {
48254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48255       };
48256     } catch (std::exception& e) {
48257       {
48258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48259       };
48260     } catch (...) {
48261       {
48262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48263       };
48264     }
48265   }
48266   jresult = (void *)result;
48267   return jresult;
48268 }
48269
48270
48271 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Begin(void * jarg1) {
48272   void * jresult ;
48273   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48274   Dali::Vector< float >::Iterator result;
48275
48276   arg1 = (Dali::Vector< float > *)jarg1;
48277   {
48278     try {
48279       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48280     } catch (std::out_of_range& e) {
48281       {
48282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (std::exception& e) {
48285       {
48286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (...) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48291       };
48292     }
48293   }
48294   jresult = (void *)result;
48295   return jresult;
48296 }
48297
48298
48299 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_End(void * jarg1) {
48300   void * jresult ;
48301   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48302   Dali::Vector< float >::Iterator result;
48303
48304   arg1 = (Dali::Vector< float > *)jarg1;
48305   {
48306     try {
48307       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48308     } catch (std::out_of_range& e) {
48309       {
48310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48311       };
48312     } catch (std::exception& e) {
48313       {
48314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48315       };
48316     } catch (...) {
48317       {
48318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48319       };
48320     }
48321   }
48322   jresult = (void *)result;
48323   return jresult;
48324 }
48325
48326
48327 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48328   void * jresult ;
48329   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48330   Dali::Vector< float >::SizeType arg2 ;
48331   Dali::Vector< float >::ItemType *result = 0 ;
48332
48333   arg1 = (Dali::Vector< float > *)jarg1;
48334   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48335   {
48336     try {
48337       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48338     } catch (std::out_of_range& e) {
48339       {
48340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48341       };
48342     } catch (std::exception& e) {
48343       {
48344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48345       };
48346     } catch (...) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48349       };
48350     }
48351   }
48352   jresult = (void *)result;
48353   return jresult;
48354 }
48355
48356
48357 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_PushBack(void * jarg1, float jarg2) {
48358   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48359   Dali::Vector< float >::ItemType *arg2 = 0 ;
48360   Dali::Vector< float >::ItemType temp2 ;
48361
48362   arg1 = (Dali::Vector< float > *)jarg1;
48363   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48364   arg2 = &temp2;
48365   {
48366     try {
48367       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48368     } catch (std::out_of_range& e) {
48369       {
48370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48371       };
48372     } catch (std::exception& e) {
48373       {
48374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48375       };
48376     } catch (...) {
48377       {
48378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48379       };
48380     }
48381   }
48382 }
48383
48384
48385 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48386   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48387   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48388   Dali::Vector< float >::ItemType *arg3 = 0 ;
48389   Dali::Vector< float >::ItemType temp3 ;
48390
48391   arg1 = (Dali::Vector< float > *)jarg1;
48392   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48393   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48394   arg3 = &temp3;
48395   {
48396     try {
48397       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48398     } catch (std::out_of_range& e) {
48399       {
48400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48401       };
48402     } catch (std::exception& e) {
48403       {
48404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48405       };
48406     } catch (...) {
48407       {
48408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48409       };
48410     }
48411   }
48412 }
48413
48414
48415 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48416   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48417   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48418   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48419   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48420
48421   arg1 = (Dali::Vector< float > *)jarg1;
48422   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48423   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48424   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48425   {
48426     try {
48427       (arg1)->Insert(arg2,arg3,arg4);
48428     } catch (std::out_of_range& e) {
48429       {
48430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48431       };
48432     } catch (std::exception& e) {
48433       {
48434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48435       };
48436     } catch (...) {
48437       {
48438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48439       };
48440     }
48441   }
48442 }
48443
48444
48445 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48446   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48447   Dali::Vector< float >::SizeType arg2 ;
48448
48449   arg1 = (Dali::Vector< float > *)jarg1;
48450   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48451   {
48452     try {
48453       (arg1)->Reserve(arg2);
48454     } catch (std::out_of_range& e) {
48455       {
48456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48457       };
48458     } catch (std::exception& e) {
48459       {
48460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48461       };
48462     } catch (...) {
48463       {
48464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48465       };
48466     }
48467   }
48468 }
48469
48470
48471 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48472   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48473   Dali::Vector< float >::SizeType arg2 ;
48474
48475   arg1 = (Dali::Vector< float > *)jarg1;
48476   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48477   {
48478     try {
48479       (arg1)->Resize(arg2);
48480     } catch (std::out_of_range& e) {
48481       {
48482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48483       };
48484     } catch (std::exception& e) {
48485       {
48486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (...) {
48489       {
48490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48491       };
48492     }
48493   }
48494 }
48495
48496
48497 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48498   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48499   Dali::Vector< float >::SizeType arg2 ;
48500   Dali::Vector< float >::ItemType *arg3 = 0 ;
48501   Dali::Vector< float >::ItemType temp3 ;
48502
48503   arg1 = (Dali::Vector< float > *)jarg1;
48504   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48505   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48506   arg3 = &temp3;
48507   {
48508     try {
48509       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48510     } catch (std::out_of_range& e) {
48511       {
48512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48513       };
48514     } catch (std::exception& e) {
48515       {
48516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48517       };
48518     } catch (...) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48521       };
48522     }
48523   }
48524 }
48525
48526
48527 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48528   void * jresult ;
48529   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48530   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48531   Dali::Vector< float >::Iterator result;
48532
48533   arg1 = (Dali::Vector< float > *)jarg1;
48534   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48535   {
48536     try {
48537       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48538     } catch (std::out_of_range& e) {
48539       {
48540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48541       };
48542     } catch (std::exception& e) {
48543       {
48544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48545       };
48546     } catch (...) {
48547       {
48548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48549       };
48550     }
48551   }
48552   jresult = (void *)result;
48553   return jresult;
48554 }
48555
48556
48557 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48558   void * jresult ;
48559   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48560   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48561   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48562   Dali::Vector< float >::Iterator result;
48563
48564   arg1 = (Dali::Vector< float > *)jarg1;
48565   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48566   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48567   {
48568     try {
48569       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48570     } catch (std::out_of_range& e) {
48571       {
48572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48573       };
48574     } catch (std::exception& e) {
48575       {
48576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48581       };
48582     }
48583   }
48584   jresult = (void *)result;
48585   return jresult;
48586 }
48587
48588
48589 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Remove(void * jarg1, void * jarg2) {
48590   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48591   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48592
48593   arg1 = (Dali::Vector< float > *)jarg1;
48594   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48595   {
48596     try {
48597       (arg1)->Remove(arg2);
48598     } catch (std::out_of_range& e) {
48599       {
48600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48601       };
48602     } catch (std::exception& e) {
48603       {
48604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48605       };
48606     } catch (...) {
48607       {
48608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48609       };
48610     }
48611   }
48612 }
48613
48614
48615 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Swap(void * jarg1, void * jarg2) {
48616   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48617   Dali::Vector< float > *arg2 = 0 ;
48618
48619   arg1 = (Dali::Vector< float > *)jarg1;
48620   arg2 = (Dali::Vector< float > *)jarg2;
48621   if (!arg2) {
48622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48623     return ;
48624   }
48625   {
48626     try {
48627       (arg1)->Swap(*arg2);
48628     } catch (std::out_of_range& e) {
48629       {
48630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48631       };
48632     } catch (std::exception& e) {
48633       {
48634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48635       };
48636     } catch (...) {
48637       {
48638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48639       };
48640     }
48641   }
48642 }
48643
48644
48645 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Clear(void * jarg1) {
48646   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48647
48648   arg1 = (Dali::Vector< float > *)jarg1;
48649   {
48650     try {
48651       (arg1)->Clear();
48652     } catch (std::out_of_range& e) {
48653       {
48654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48655       };
48656     } catch (std::exception& e) {
48657       {
48658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48659       };
48660     } catch (...) {
48661       {
48662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48663       };
48664     }
48665   }
48666 }
48667
48668
48669 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Release(void * jarg1) {
48670   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48671
48672   arg1 = (Dali::Vector< float > *)jarg1;
48673   {
48674     try {
48675       (arg1)->Release();
48676     } catch (std::out_of_range& e) {
48677       {
48678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (std::exception& e) {
48681       {
48682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48683       };
48684     } catch (...) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48687       };
48688     }
48689   }
48690 }
48691
48692
48693 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_BaseType_get() {
48694   int jresult ;
48695   int result;
48696
48697   result = (int)Dali::Vector< unsigned char >::BaseType;
48698   jresult = (int)result;
48699   return jresult;
48700 }
48701
48702
48703 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUnsignedChar__SWIG_0() {
48704   void * jresult ;
48705   Dali::Vector< unsigned char > *result = 0 ;
48706
48707   {
48708     try {
48709       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48710     } catch (std::out_of_range& e) {
48711       {
48712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48713       };
48714     } catch (std::exception& e) {
48715       {
48716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48717       };
48718     } catch (...) {
48719       {
48720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48721       };
48722     }
48723   }
48724   jresult = (void *)result;
48725   return jresult;
48726 }
48727
48728
48729 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorUnsignedChar(void * jarg1) {
48730   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48731
48732   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48733   {
48734     try {
48735       delete arg1;
48736     } catch (std::out_of_range& e) {
48737       {
48738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48739       };
48740     } catch (std::exception& e) {
48741       {
48742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48743       };
48744     } catch (...) {
48745       {
48746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48747       };
48748     }
48749   }
48750 }
48751
48752
48753 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48754   void * jresult ;
48755   Dali::Vector< unsigned char > *arg1 = 0 ;
48756   Dali::Vector< unsigned char > *result = 0 ;
48757
48758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48759   if (!arg1) {
48760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48761     return 0;
48762   }
48763   {
48764     try {
48765       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48766     } catch (std::out_of_range& e) {
48767       {
48768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48769       };
48770     } catch (std::exception& e) {
48771       {
48772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48777       };
48778     }
48779   }
48780   jresult = (void *)result;
48781   return jresult;
48782 }
48783
48784
48785 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48786   void * jresult ;
48787   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48788   Dali::Vector< unsigned char > *arg2 = 0 ;
48789   Dali::Vector< unsigned char > *result = 0 ;
48790
48791   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48792   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48793   if (!arg2) {
48794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48795     return 0;
48796   }
48797   {
48798     try {
48799       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48800     } catch (std::out_of_range& e) {
48801       {
48802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48803       };
48804     } catch (std::exception& e) {
48805       {
48806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48807       };
48808     } catch (...) {
48809       {
48810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48811       };
48812     }
48813   }
48814   jresult = (void *)result;
48815   return jresult;
48816 }
48817
48818
48819 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Begin(void * jarg1) {
48820   void * jresult ;
48821   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48822   Dali::Vector< unsigned char >::Iterator result;
48823
48824   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48825   {
48826     try {
48827       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
48828     } catch (std::out_of_range& e) {
48829       {
48830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48831       };
48832     } catch (std::exception& e) {
48833       {
48834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48835       };
48836     } catch (...) {
48837       {
48838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48839       };
48840     }
48841   }
48842   jresult = (void *)result;
48843   return jresult;
48844 }
48845
48846
48847 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_End(void * jarg1) {
48848   void * jresult ;
48849   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48850   Dali::Vector< unsigned char >::Iterator result;
48851
48852   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48853   {
48854     try {
48855       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
48856     } catch (std::out_of_range& e) {
48857       {
48858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48859       };
48860     } catch (std::exception& e) {
48861       {
48862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48863       };
48864     } catch (...) {
48865       {
48866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48867       };
48868     }
48869   }
48870   jresult = (void *)result;
48871   return jresult;
48872 }
48873
48874
48875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48876   void * jresult ;
48877   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48878   Dali::Vector< unsigned char >::SizeType arg2 ;
48879   Dali::Vector< unsigned char >::ItemType *result = 0 ;
48880
48881   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48882   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48883   {
48884     try {
48885       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
48886     } catch (std::out_of_range& e) {
48887       {
48888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (std::exception& e) {
48891       {
48892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48893       };
48894     } catch (...) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48897       };
48898     }
48899   }
48900   jresult = (void *)result;
48901   return jresult;
48902 }
48903
48904
48905 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
48906   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48907   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
48908   Dali::Vector< unsigned char >::ItemType temp2 ;
48909
48910   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48911   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
48912   arg2 = &temp2;
48913   {
48914     try {
48915       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
48916     } catch (std::out_of_range& e) {
48917       {
48918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48919       };
48920     } catch (std::exception& e) {
48921       {
48922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48923       };
48924     } catch (...) {
48925       {
48926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48927       };
48928     }
48929   }
48930 }
48931
48932
48933 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
48934   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48935   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48936   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48937   Dali::Vector< unsigned char >::ItemType temp3 ;
48938
48939   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48940   arg2 = jarg2;
48941   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48942   arg3 = &temp3;
48943   {
48944     try {
48945       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48946     } catch (std::out_of_range& e) {
48947       {
48948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48949       };
48950     } catch (std::exception& e) {
48951       {
48952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48953       };
48954     } catch (...) {
48955       {
48956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48957       };
48958     }
48959   }
48960
48961
48962 }
48963
48964
48965 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
48966   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48967   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48968   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48969   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48970
48971   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48972   arg2 = jarg2;
48973   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48974   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
48975   {
48976     try {
48977       (arg1)->Insert(arg2,arg3,arg4);
48978     } catch (std::out_of_range& e) {
48979       {
48980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48981       };
48982     } catch (std::exception& e) {
48983       {
48984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48985       };
48986     } catch (...) {
48987       {
48988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48989       };
48990     }
48991   }
48992
48993
48994 }
48995
48996
48997 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
48998   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48999   Dali::Vector< unsigned char >::SizeType arg2 ;
49000
49001   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49002   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49003   {
49004     try {
49005       (arg1)->Reserve(arg2);
49006     } catch (std::out_of_range& e) {
49007       {
49008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49009       };
49010     } catch (std::exception& e) {
49011       {
49012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49013       };
49014     } catch (...) {
49015       {
49016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49017       };
49018     }
49019   }
49020 }
49021
49022
49023 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49024   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49025   Dali::Vector< unsigned char >::SizeType arg2 ;
49026
49027   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49028   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49029   {
49030     try {
49031       (arg1)->Resize(arg2);
49032     } catch (std::out_of_range& e) {
49033       {
49034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49035       };
49036     } catch (std::exception& e) {
49037       {
49038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49039       };
49040     } catch (...) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49043       };
49044     }
49045   }
49046 }
49047
49048
49049 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49050   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49051   Dali::Vector< unsigned char >::SizeType arg2 ;
49052   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49053   Dali::Vector< unsigned char >::ItemType temp3 ;
49054
49055   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49056   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49057   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49058   arg3 = &temp3;
49059   {
49060     try {
49061       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49062     } catch (std::out_of_range& e) {
49063       {
49064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49065       };
49066     } catch (std::exception& e) {
49067       {
49068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49069       };
49070     } catch (...) {
49071       {
49072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49073       };
49074     }
49075   }
49076 }
49077
49078
49079 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49080   void * jresult ;
49081   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49082   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49083   Dali::Vector< unsigned char >::Iterator result;
49084
49085   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49086   arg2 = jarg2;
49087   {
49088     try {
49089       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49090     } catch (std::out_of_range& e) {
49091       {
49092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49093       };
49094     } catch (std::exception& e) {
49095       {
49096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49097       };
49098     } catch (...) {
49099       {
49100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49101       };
49102     }
49103   }
49104   jresult = (void *)result;
49105
49106
49107   return jresult;
49108 }
49109
49110
49111 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49112   void * jresult ;
49113   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49114   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49115   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49116   Dali::Vector< unsigned char >::Iterator result;
49117
49118   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49119   arg2 = jarg2;
49120   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49121   {
49122     try {
49123       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49124     } catch (std::out_of_range& e) {
49125       {
49126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49127       };
49128     } catch (std::exception& e) {
49129       {
49130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49131       };
49132     } catch (...) {
49133       {
49134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49135       };
49136     }
49137   }
49138   jresult = (void *)result;
49139
49140
49141   return jresult;
49142 }
49143
49144
49145 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49146   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49147   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49148
49149   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49150   arg2 = jarg2;
49151   {
49152     try {
49153       (arg1)->Remove(arg2);
49154     } catch (std::out_of_range& e) {
49155       {
49156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49157       };
49158     } catch (std::exception& e) {
49159       {
49160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49161       };
49162     } catch (...) {
49163       {
49164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49165       };
49166     }
49167   }
49168
49169
49170 }
49171
49172
49173 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49174   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49175   Dali::Vector< unsigned char > *arg2 = 0 ;
49176
49177   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49178   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49179   if (!arg2) {
49180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49181     return ;
49182   }
49183   {
49184     try {
49185       (arg1)->Swap(*arg2);
49186     } catch (std::out_of_range& e) {
49187       {
49188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49189       };
49190     } catch (std::exception& e) {
49191       {
49192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49193       };
49194     } catch (...) {
49195       {
49196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49197       };
49198     }
49199   }
49200 }
49201
49202
49203 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Clear(void * jarg1) {
49204   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49205
49206   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49207   {
49208     try {
49209       (arg1)->Clear();
49210     } catch (std::out_of_range& e) {
49211       {
49212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (std::exception& e) {
49215       {
49216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (...) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49221       };
49222     }
49223   }
49224 }
49225
49226
49227 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Release(void * jarg1) {
49228   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49229
49230   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49231   {
49232     try {
49233       (arg1)->Release();
49234     } catch (std::out_of_range& e) {
49235       {
49236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49237       };
49238     } catch (std::exception& e) {
49239       {
49240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49241       };
49242     } catch (...) {
49243       {
49244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49245       };
49246     }
49247   }
49248 }
49249
49250
49251 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorUint16Pair_BaseType_get() {
49252   int jresult ;
49253   int result;
49254
49255   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49256   jresult = (int)result;
49257   return jresult;
49258 }
49259
49260
49261 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUint16Pair__SWIG_0() {
49262   void * jresult ;
49263   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49264
49265   {
49266     try {
49267       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49268     } catch (std::out_of_range& e) {
49269       {
49270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49271       };
49272     } catch (std::exception& e) {
49273       {
49274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49275       };
49276     } catch (...) {
49277       {
49278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49279       };
49280     }
49281   }
49282   jresult = (void *)result;
49283   return jresult;
49284 }
49285
49286
49287 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorUint16Pair(void * jarg1) {
49288   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49289
49290   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49291   {
49292     try {
49293       delete arg1;
49294     } catch (std::out_of_range& e) {
49295       {
49296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49297       };
49298     } catch (std::exception& e) {
49299       {
49300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49301       };
49302     } catch (...) {
49303       {
49304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49305       };
49306     }
49307   }
49308 }
49309
49310
49311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49312   void * jresult ;
49313   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49314   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49315
49316   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49317   if (!arg1) {
49318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49319     return 0;
49320   }
49321   {
49322     try {
49323       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49324     } catch (std::out_of_range& e) {
49325       {
49326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49327       };
49328     } catch (std::exception& e) {
49329       {
49330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49331       };
49332     } catch (...) {
49333       {
49334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49335       };
49336     }
49337   }
49338   jresult = (void *)result;
49339   return jresult;
49340 }
49341
49342
49343 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49344   void * jresult ;
49345   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49346   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49347   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49348
49349   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49350   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49351   if (!arg2) {
49352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49353     return 0;
49354   }
49355   {
49356     try {
49357       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49358     } catch (std::out_of_range& e) {
49359       {
49360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49361       };
49362     } catch (std::exception& e) {
49363       {
49364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49365       };
49366     } catch (...) {
49367       {
49368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49369       };
49370     }
49371   }
49372   jresult = (void *)result;
49373   return jresult;
49374 }
49375
49376
49377 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Begin(void * jarg1) {
49378   void * jresult ;
49379   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49380   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49381
49382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49383   {
49384     try {
49385       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49386     } catch (std::out_of_range& e) {
49387       {
49388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49389       };
49390     } catch (std::exception& e) {
49391       {
49392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49393       };
49394     } catch (...) {
49395       {
49396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49397       };
49398     }
49399   }
49400   jresult = (void *)result;
49401   return jresult;
49402 }
49403
49404
49405 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_End(void * jarg1) {
49406   void * jresult ;
49407   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49408   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49409
49410   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49411   {
49412     try {
49413       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49414     } catch (std::out_of_range& e) {
49415       {
49416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49417       };
49418     } catch (std::exception& e) {
49419       {
49420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49421       };
49422     } catch (...) {
49423       {
49424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49425       };
49426     }
49427   }
49428   jresult = (void *)result;
49429   return jresult;
49430 }
49431
49432
49433 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49434   void * jresult ;
49435   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49436   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49437   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49438
49439   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49440   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49441   {
49442     try {
49443       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49444     } catch (std::out_of_range& e) {
49445       {
49446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49447       };
49448     } catch (std::exception& e) {
49449       {
49450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49451       };
49452     } catch (...) {
49453       {
49454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49455       };
49456     }
49457   }
49458   jresult = (void *)result;
49459   return jresult;
49460 }
49461
49462
49463 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49464   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49465   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49466
49467   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49468   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49469   if (!arg2) {
49470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49471     return ;
49472   }
49473   {
49474     try {
49475       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49476     } catch (std::out_of_range& e) {
49477       {
49478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49479       };
49480     } catch (std::exception& e) {
49481       {
49482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49483       };
49484     } catch (...) {
49485       {
49486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49487       };
49488     }
49489   }
49490 }
49491
49492
49493 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49494   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49495   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49496   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49497
49498   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49499   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49500   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49501   if (!arg3) {
49502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49503     return ;
49504   }
49505   {
49506     try {
49507       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49508     } catch (std::out_of_range& e) {
49509       {
49510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49511       };
49512     } catch (std::exception& e) {
49513       {
49514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49515       };
49516     } catch (...) {
49517       {
49518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49519       };
49520     }
49521   }
49522 }
49523
49524
49525 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49526   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49527   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49528   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49529   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49530
49531   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49532   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49533   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49534   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49535   {
49536     try {
49537       (arg1)->Insert(arg2,arg3,arg4);
49538     } catch (std::out_of_range& e) {
49539       {
49540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49541       };
49542     } catch (std::exception& e) {
49543       {
49544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49545       };
49546     } catch (...) {
49547       {
49548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49549       };
49550     }
49551   }
49552 }
49553
49554
49555 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49556   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49557   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49558
49559   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49560   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49561   {
49562     try {
49563       (arg1)->Reserve(arg2);
49564     } catch (std::out_of_range& e) {
49565       {
49566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49567       };
49568     } catch (std::exception& e) {
49569       {
49570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49571       };
49572     } catch (...) {
49573       {
49574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49575       };
49576     }
49577   }
49578 }
49579
49580
49581 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49582   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49583   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49584
49585   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49586   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49587   {
49588     try {
49589       (arg1)->Resize(arg2);
49590     } catch (std::out_of_range& e) {
49591       {
49592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49593       };
49594     } catch (std::exception& e) {
49595       {
49596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49597       };
49598     } catch (...) {
49599       {
49600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49601       };
49602     }
49603   }
49604 }
49605
49606
49607 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49608   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49609   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49610   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49611
49612   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49613   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49614   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49615   if (!arg3) {
49616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49617     return ;
49618   }
49619   {
49620     try {
49621       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49622     } catch (std::out_of_range& e) {
49623       {
49624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49625       };
49626     } catch (std::exception& e) {
49627       {
49628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49629       };
49630     } catch (...) {
49631       {
49632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49633       };
49634     }
49635   }
49636 }
49637
49638
49639 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49640   void * jresult ;
49641   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49642   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49643   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49644
49645   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49646   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49647   {
49648     try {
49649       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49650     } catch (std::out_of_range& e) {
49651       {
49652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49653       };
49654     } catch (std::exception& e) {
49655       {
49656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49657       };
49658     } catch (...) {
49659       {
49660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49661       };
49662     }
49663   }
49664   jresult = (void *)result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49670   void * jresult ;
49671   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49672   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49673   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49674   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49675
49676   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49677   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49678   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49679   {
49680     try {
49681       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
49682     } catch (std::out_of_range& e) {
49683       {
49684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49685       };
49686     } catch (std::exception& e) {
49687       {
49688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49689       };
49690     } catch (...) {
49691       {
49692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49693       };
49694     }
49695   }
49696   jresult = (void *)result;
49697   return jresult;
49698 }
49699
49700
49701 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
49702   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49703   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49704
49705   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49706   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49707   {
49708     try {
49709       (arg1)->Remove(arg2);
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (...) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49721       };
49722     }
49723   }
49724 }
49725
49726
49727 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
49728   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49729   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49730
49731   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49732   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49733   if (!arg2) {
49734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
49735     return ;
49736   }
49737   {
49738     try {
49739       (arg1)->Swap(*arg2);
49740     } catch (std::out_of_range& e) {
49741       {
49742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49743       };
49744     } catch (std::exception& e) {
49745       {
49746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49747       };
49748     } catch (...) {
49749       {
49750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49751       };
49752     }
49753   }
49754 }
49755
49756
49757 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Clear(void * jarg1) {
49758   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49759
49760   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49761   {
49762     try {
49763       (arg1)->Clear();
49764     } catch (std::out_of_range& e) {
49765       {
49766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49767       };
49768     } catch (std::exception& e) {
49769       {
49770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49771       };
49772     } catch (...) {
49773       {
49774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49775       };
49776     }
49777   }
49778 }
49779
49780
49781 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Release(void * jarg1) {
49782   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49783
49784   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49785   {
49786     try {
49787       (arg1)->Release();
49788     } catch (std::out_of_range& e) {
49789       {
49790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49791       };
49792     } catch (std::exception& e) {
49793       {
49794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49795       };
49796     } catch (...) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49799       };
49800     }
49801   }
49802 }
49803
49804
49805 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VoidSignal() {
49806   void * jresult ;
49807   Dali::Signal< void () > *result = 0 ;
49808
49809   {
49810     try {
49811       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
49812     } catch (std::out_of_range& e) {
49813       {
49814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49815       };
49816     } catch (std::exception& e) {
49817       {
49818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49819       };
49820     } catch (...) {
49821       {
49822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49823       };
49824     }
49825   }
49826   jresult = (void *)result;
49827   return jresult;
49828 }
49829
49830
49831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VoidSignal(void * jarg1) {
49832   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49833
49834   arg1 = (Dali::Signal< void () > *)jarg1;
49835   {
49836     try {
49837       delete arg1;
49838     } catch (std::out_of_range& e) {
49839       {
49840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49841       };
49842     } catch (std::exception& e) {
49843       {
49844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49845       };
49846     } catch (...) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49849       };
49850     }
49851   }
49852 }
49853
49854
49855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VoidSignal_Empty(void * jarg1) {
49856   unsigned int jresult ;
49857   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49858   bool result;
49859
49860   arg1 = (Dali::Signal< void () > *)jarg1;
49861   {
49862     try {
49863       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
49864     } catch (std::out_of_range& e) {
49865       {
49866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49867       };
49868     } catch (std::exception& e) {
49869       {
49870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49875       };
49876     }
49877   }
49878   jresult = result;
49879   return jresult;
49880 }
49881
49882
49883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VoidSignal_GetConnectionCount(void * jarg1) {
49884   unsigned long jresult ;
49885   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49886   std::size_t result;
49887
49888   arg1 = (Dali::Signal< void () > *)jarg1;
49889   {
49890     try {
49891       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
49892     } catch (std::out_of_range& e) {
49893       {
49894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49895       };
49896     } catch (std::exception& e) {
49897       {
49898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49899       };
49900     } catch (...) {
49901       {
49902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49903       };
49904     }
49905   }
49906   jresult = (unsigned long)result;
49907   return jresult;
49908 }
49909
49910
49911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
49912   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49913   void (*arg2)() = (void (*)()) 0 ;
49914
49915   arg1 = (Dali::Signal< void () > *)jarg1;
49916   arg2 = (void (*)())jarg2;
49917   {
49918     try {
49919       (arg1)->Connect(arg2);
49920     } catch (std::out_of_range& e) {
49921       {
49922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (std::exception& e) {
49925       {
49926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49927       };
49928     } catch (...) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49931       };
49932     }
49933   }
49934 }
49935
49936
49937 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
49938   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49939   void (*arg2)() = (void (*)()) 0 ;
49940
49941   arg1 = (Dali::Signal< void () > *)jarg1;
49942   arg2 = (void (*)())jarg2;
49943   {
49944     try {
49945       (arg1)->Disconnect(arg2);
49946     } catch (std::out_of_range& e) {
49947       {
49948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49949       };
49950     } catch (std::exception& e) {
49951       {
49952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49953       };
49954     } catch (...) {
49955       {
49956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49957       };
49958     }
49959   }
49960 }
49961
49962
49963 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
49964   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49965   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
49966   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
49967
49968   arg1 = (Dali::Signal< void () > *)jarg1;
49969   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
49970   arg3 = (Dali::FunctorDelegate *)jarg3;
49971   {
49972     try {
49973       (arg1)->Connect(arg2,arg3);
49974     } catch (std::out_of_range& e) {
49975       {
49976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49977       };
49978     } catch (std::exception& e) {
49979       {
49980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49981       };
49982     } catch (...) {
49983       {
49984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49985       };
49986     }
49987   }
49988 }
49989
49990
49991 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Emit(void * jarg1) {
49992   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49993
49994   arg1 = (Dali::Signal< void () > *)jarg1;
49995   {
49996     try {
49997       (arg1)->Emit();
49998     } catch (std::out_of_range& e) {
49999       {
50000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50001       };
50002     } catch (std::exception& e) {
50003       {
50004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50005       };
50006     } catch (...) {
50007       {
50008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50009       };
50010     }
50011   }
50012 }
50013
50014
50015 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BoolSignal() {
50016   void * jresult ;
50017   Dali::Signal< bool () > *result = 0 ;
50018
50019   {
50020     try {
50021       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
50022     } catch (std::out_of_range& e) {
50023       {
50024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50025       };
50026     } catch (std::exception& e) {
50027       {
50028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50029       };
50030     } catch (...) {
50031       {
50032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50033       };
50034     }
50035   }
50036   jresult = (void *)result;
50037   return jresult;
50038 }
50039
50040
50041 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BoolSignal(void * jarg1) {
50042   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50043
50044   arg1 = (Dali::Signal< bool () > *)jarg1;
50045   {
50046     try {
50047       delete arg1;
50048     } catch (std::out_of_range& e) {
50049       {
50050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50051       };
50052     } catch (std::exception& e) {
50053       {
50054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50055       };
50056     } catch (...) {
50057       {
50058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50059       };
50060     }
50061   }
50062 }
50063
50064
50065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BoolSignal_Empty(void * jarg1) {
50066   unsigned int jresult ;
50067   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50068   bool result;
50069
50070   arg1 = (Dali::Signal< bool () > *)jarg1;
50071   {
50072     try {
50073       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
50074     } catch (std::out_of_range& e) {
50075       {
50076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50077       };
50078     } catch (std::exception& e) {
50079       {
50080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50081       };
50082     } catch (...) {
50083       {
50084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50085       };
50086     }
50087   }
50088   jresult = result;
50089   return jresult;
50090 }
50091
50092
50093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_BoolSignal_GetConnectionCount(void * jarg1) {
50094   unsigned long jresult ;
50095   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50096   std::size_t result;
50097
50098   arg1 = (Dali::Signal< bool () > *)jarg1;
50099   {
50100     try {
50101       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
50102     } catch (std::out_of_range& e) {
50103       {
50104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50105       };
50106     } catch (std::exception& e) {
50107       {
50108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50109       };
50110     } catch (...) {
50111       {
50112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50113       };
50114     }
50115   }
50116   jresult = (unsigned long)result;
50117   return jresult;
50118 }
50119
50120
50121 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50122   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50123   bool (*arg2)() = (bool (*)()) 0 ;
50124
50125   arg1 = (Dali::Signal< bool () > *)jarg1;
50126   arg2 = (bool (*)())jarg2;
50127   {
50128     try {
50129       (arg1)->Connect(arg2);
50130     } catch (std::out_of_range& e) {
50131       {
50132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50133       };
50134     } catch (std::exception& e) {
50135       {
50136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50137       };
50138     } catch (...) {
50139       {
50140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50141       };
50142     }
50143   }
50144 }
50145
50146
50147 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Disconnect(void * jarg1, void * jarg2) {
50148   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50149   bool (*arg2)() = (bool (*)()) 0 ;
50150
50151   arg1 = (Dali::Signal< bool () > *)jarg1;
50152   arg2 = (bool (*)())jarg2;
50153   {
50154     try {
50155       (arg1)->Disconnect(arg2);
50156     } catch (std::out_of_range& e) {
50157       {
50158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50159       };
50160     } catch (std::exception& e) {
50161       {
50162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50163       };
50164     } catch (...) {
50165       {
50166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50167       };
50168     }
50169   }
50170 }
50171
50172
50173 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50174   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50175   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50176   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50177
50178   arg1 = (Dali::Signal< bool () > *)jarg1;
50179   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50180   arg3 = (Dali::FunctorDelegate *)jarg3;
50181   {
50182     try {
50183       (arg1)->Connect(arg2,arg3);
50184     } catch (std::out_of_range& e) {
50185       {
50186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50187       };
50188     } catch (std::exception& e) {
50189       {
50190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50191       };
50192     } catch (...) {
50193       {
50194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50195       };
50196     }
50197   }
50198 }
50199
50200
50201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BoolSignal_Emit(void * jarg1) {
50202   unsigned int jresult ;
50203   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50204   bool result;
50205
50206   arg1 = (Dali::Signal< bool () > *)jarg1;
50207   {
50208     try {
50209       result = (bool)(arg1)->Emit();
50210     } catch (std::out_of_range& e) {
50211       {
50212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50213       };
50214     } catch (std::exception& e) {
50215       {
50216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50217       };
50218     } catch (...) {
50219       {
50220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50221       };
50222     }
50223   }
50224   jresult = result;
50225   return jresult;
50226 }
50227
50228
50229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FloatSignal_Empty(void * jarg1) {
50230   unsigned int jresult ;
50231   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50232   bool result;
50233
50234   arg1 = (Dali::Signal< void (float) > *)jarg1;
50235   {
50236     try {
50237       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50238     } catch (std::out_of_range& e) {
50239       {
50240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50241       };
50242     } catch (std::exception& e) {
50243       {
50244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50245       };
50246     } catch (...) {
50247       {
50248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50249       };
50250     }
50251   }
50252   jresult = result;
50253   return jresult;
50254 }
50255
50256
50257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FloatSignal_GetConnectionCount(void * jarg1) {
50258   unsigned long jresult ;
50259   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50260   std::size_t result;
50261
50262   arg1 = (Dali::Signal< void (float) > *)jarg1;
50263   {
50264     try {
50265       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50266     } catch (std::out_of_range& e) {
50267       {
50268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50269       };
50270     } catch (std::exception& e) {
50271       {
50272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50273       };
50274     } catch (...) {
50275       {
50276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50277       };
50278     }
50279   }
50280   jresult = (unsigned long)result;
50281   return jresult;
50282 }
50283
50284
50285 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Connect(void * jarg1, void * jarg2) {
50286   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50287   void (*arg2)(float) = (void (*)(float)) 0 ;
50288
50289   arg1 = (Dali::Signal< void (float) > *)jarg1;
50290   arg2 = (void (*)(float))jarg2;
50291   {
50292     try {
50293       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50294     } catch (std::out_of_range& e) {
50295       {
50296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50297       };
50298     } catch (std::exception& e) {
50299       {
50300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50301       };
50302     } catch (...) {
50303       {
50304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50305       };
50306     }
50307   }
50308 }
50309
50310
50311 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50312   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50313   void (*arg2)(float) = (void (*)(float)) 0 ;
50314
50315   arg1 = (Dali::Signal< void (float) > *)jarg1;
50316   arg2 = (void (*)(float))jarg2;
50317   {
50318     try {
50319       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50320     } catch (std::out_of_range& e) {
50321       {
50322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50323       };
50324     } catch (std::exception& e) {
50325       {
50326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50327       };
50328     } catch (...) {
50329       {
50330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50331       };
50332     }
50333   }
50334 }
50335
50336
50337 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Emit(void * jarg1, float jarg2) {
50338   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50339   float arg2 ;
50340
50341   arg1 = (Dali::Signal< void (float) > *)jarg1;
50342   arg2 = (float)jarg2;
50343   {
50344     try {
50345       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50346     } catch (std::out_of_range& e) {
50347       {
50348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50349       };
50350     } catch (std::exception& e) {
50351       {
50352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50353       };
50354     } catch (...) {
50355       {
50356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50357       };
50358     }
50359   }
50360 }
50361
50362
50363 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FloatSignal() {
50364   void * jresult ;
50365   Dali::Signal< void (float) > *result = 0 ;
50366
50367   {
50368     try {
50369       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50370     } catch (std::out_of_range& e) {
50371       {
50372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (std::exception& e) {
50375       {
50376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50377       };
50378     } catch (...) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50381       };
50382     }
50383   }
50384   jresult = (void *)result;
50385   return jresult;
50386 }
50387
50388
50389 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FloatSignal(void * jarg1) {
50390   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50391
50392   arg1 = (Dali::Signal< void (float) > *)jarg1;
50393   {
50394     try {
50395       delete arg1;
50396     } catch (std::out_of_range& e) {
50397       {
50398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50399       };
50400     } catch (std::exception& e) {
50401       {
50402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50403       };
50404     } catch (...) {
50405       {
50406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50407       };
50408     }
50409   }
50410 }
50411
50412
50413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Empty(void * jarg1) {
50414   unsigned int jresult ;
50415   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50416   bool result;
50417
50418   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50419   {
50420     try {
50421       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50422     } catch (std::out_of_range& e) {
50423       {
50424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50425       };
50426     } catch (std::exception& e) {
50427       {
50428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50429       };
50430     } catch (...) {
50431       {
50432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50433       };
50434     }
50435   }
50436   jresult = result;
50437   return jresult;
50438 }
50439
50440
50441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50442   unsigned long jresult ;
50443   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50444   std::size_t result;
50445
50446   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50447   {
50448     try {
50449       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50450     } catch (std::out_of_range& e) {
50451       {
50452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50453       };
50454     } catch (std::exception& e) {
50455       {
50456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50457       };
50458     } catch (...) {
50459       {
50460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50461       };
50462     }
50463   }
50464   jresult = (unsigned long)result;
50465   return jresult;
50466 }
50467
50468
50469 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50470   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50471   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50472
50473   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50474   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50475   {
50476     try {
50477       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50478     } catch (std::out_of_range& e) {
50479       {
50480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50481       };
50482     } catch (std::exception& e) {
50483       {
50484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50485       };
50486     } catch (...) {
50487       {
50488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50489       };
50490     }
50491   }
50492 }
50493
50494
50495 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50496   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50497   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50498
50499   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50500   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50501   {
50502     try {
50503       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50504     } catch (std::out_of_range& e) {
50505       {
50506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50507       };
50508     } catch (std::exception& e) {
50509       {
50510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50511       };
50512     } catch (...) {
50513       {
50514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50515       };
50516     }
50517   }
50518 }
50519
50520
50521 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50522   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50523   Dali::BaseHandle arg2 ;
50524   Dali::BaseHandle *argp2 ;
50525
50526   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50527   argp2 = (Dali::BaseHandle *)jarg2;
50528   if (!argp2) {
50529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50530     return ;
50531   }
50532   arg2 = *argp2;
50533   {
50534     try {
50535       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50536     } catch (std::out_of_range& e) {
50537       {
50538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50539       };
50540     } catch (std::exception& e) {
50541       {
50542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50543       };
50544     } catch (...) {
50545       {
50546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50547       };
50548     }
50549   }
50550 }
50551
50552
50553 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectCreatedSignal() {
50554   void * jresult ;
50555   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50556
50557   {
50558     try {
50559       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50560     } catch (std::out_of_range& e) {
50561       {
50562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50563       };
50564     } catch (std::exception& e) {
50565       {
50566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50567       };
50568     } catch (...) {
50569       {
50570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50571       };
50572     }
50573   }
50574   jresult = (void *)result;
50575   return jresult;
50576 }
50577
50578
50579 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectCreatedSignal(void * jarg1) {
50580   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50581
50582   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50583   {
50584     try {
50585       delete arg1;
50586     } catch (std::out_of_range& e) {
50587       {
50588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50589       };
50590     } catch (std::exception& e) {
50591       {
50592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50593       };
50594     } catch (...) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50597       };
50598     }
50599   }
50600 }
50601
50602
50603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Empty(void * jarg1) {
50604   unsigned int jresult ;
50605   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50606   bool result;
50607
50608   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50609   {
50610     try {
50611       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50612     } catch (std::out_of_range& e) {
50613       {
50614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50615       };
50616     } catch (std::exception& e) {
50617       {
50618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50619       };
50620     } catch (...) {
50621       {
50622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50623       };
50624     }
50625   }
50626   jresult = result;
50627   return jresult;
50628 }
50629
50630
50631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50632   unsigned long jresult ;
50633   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50634   std::size_t result;
50635
50636   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50637   {
50638     try {
50639       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50640     } catch (std::out_of_range& e) {
50641       {
50642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50643       };
50644     } catch (std::exception& e) {
50645       {
50646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50647       };
50648     } catch (...) {
50649       {
50650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50651       };
50652     }
50653   }
50654   jresult = (unsigned long)result;
50655   return jresult;
50656 }
50657
50658
50659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50660   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50661   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50662
50663   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50664   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50665   {
50666     try {
50667       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50668     } catch (std::out_of_range& e) {
50669       {
50670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50671       };
50672     } catch (std::exception& e) {
50673       {
50674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50675       };
50676     } catch (...) {
50677       {
50678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50679       };
50680     }
50681   }
50682 }
50683
50684
50685 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50686   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50687   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50688
50689   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50690   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50691   {
50692     try {
50693       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50694     } catch (std::out_of_range& e) {
50695       {
50696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50697       };
50698     } catch (std::exception& e) {
50699       {
50700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50701       };
50702     } catch (...) {
50703       {
50704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50705       };
50706     }
50707   }
50708 }
50709
50710
50711 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
50712   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50713   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
50714
50715   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50716   arg2 = (Dali::RefObject *)jarg2;
50717   {
50718     try {
50719       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
50720     } catch (std::out_of_range& e) {
50721       {
50722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50723       };
50724     } catch (std::exception& e) {
50725       {
50726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50727       };
50728     } catch (...) {
50729       {
50730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50731       };
50732     }
50733   }
50734 }
50735
50736
50737 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectDestroyedSignal() {
50738   void * jresult ;
50739   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
50740
50741   {
50742     try {
50743       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50751       };
50752     } catch (...) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50755       };
50756     }
50757   }
50758   jresult = (void *)result;
50759   return jresult;
50760 }
50761
50762
50763 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectDestroyedSignal(void * jarg1) {
50764   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50765
50766   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50767   {
50768     try {
50769       delete arg1;
50770     } catch (std::out_of_range& e) {
50771       {
50772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50773       };
50774     } catch (std::exception& e) {
50775       {
50776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50777       };
50778     } catch (...) {
50779       {
50780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50781       };
50782     }
50783   }
50784 }
50785
50786
50787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Empty(void * jarg1) {
50788   unsigned int jresult ;
50789   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50790   bool result;
50791
50792   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50793   {
50794     try {
50795       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50796     } catch (std::out_of_range& e) {
50797       {
50798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50799       };
50800     } catch (std::exception& e) {
50801       {
50802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (...) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50807       };
50808     }
50809   }
50810   jresult = result;
50811   return jresult;
50812 }
50813
50814
50815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
50816   unsigned long jresult ;
50817   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50818   std::size_t result;
50819
50820   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50821   {
50822     try {
50823       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50824     } catch (std::out_of_range& e) {
50825       {
50826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50827       };
50828     } catch (std::exception& e) {
50829       {
50830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50831       };
50832     } catch (...) {
50833       {
50834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50835       };
50836     }
50837   }
50838   jresult = (unsigned long)result;
50839   return jresult;
50840 }
50841
50842
50843 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
50844   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50845   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50846
50847   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50848   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50849   {
50850     try {
50851       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
50852     } catch (std::out_of_range& e) {
50853       {
50854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50855       };
50856     } catch (std::exception& e) {
50857       {
50858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50859       };
50860     } catch (...) {
50861       {
50862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50863       };
50864     }
50865   }
50866 }
50867
50868
50869 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
50870   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50871   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50872
50873   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50874   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50875   {
50876     try {
50877       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
50878     } catch (std::out_of_range& e) {
50879       {
50880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50881       };
50882     } catch (std::exception& e) {
50883       {
50884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50885       };
50886     } catch (...) {
50887       {
50888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50889       };
50890     }
50891   }
50892 }
50893
50894
50895 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
50896   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50897   Dali::PropertyNotification *arg2 = 0 ;
50898
50899   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50900   arg2 = (Dali::PropertyNotification *)jarg2;
50901   if (!arg2) {
50902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
50903     return ;
50904   }
50905   {
50906     try {
50907       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
50908     } catch (std::out_of_range& e) {
50909       {
50910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50911       };
50912     } catch (std::exception& e) {
50913       {
50914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50915       };
50916     } catch (...) {
50917       {
50918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50919       };
50920     }
50921   }
50922 }
50923
50924
50925 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotifySignal() {
50926   void * jresult ;
50927   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
50928
50929   {
50930     try {
50931       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
50932     } catch (std::out_of_range& e) {
50933       {
50934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50935       };
50936     } catch (std::exception& e) {
50937       {
50938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50939       };
50940     } catch (...) {
50941       {
50942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50943       };
50944     }
50945   }
50946   jresult = (void *)result;
50947   return jresult;
50948 }
50949
50950
50951 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyNotifySignal(void * jarg1) {
50952   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50953
50954   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50955   {
50956     try {
50957       delete arg1;
50958     } catch (std::out_of_range& e) {
50959       {
50960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50961       };
50962     } catch (std::exception& e) {
50963       {
50964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50965       };
50966     } catch (...) {
50967       {
50968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50969       };
50970     }
50971   }
50972 }
50973
50974
50975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ImageSignal_Empty(void * jarg1) {
50976   unsigned int jresult ;
50977   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
50978   bool result;
50979
50980   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
50981   {
50982     try {
50983       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
50984     } catch (std::out_of_range& e) {
50985       {
50986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50987       };
50988     } catch (std::exception& e) {
50989       {
50990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50991       };
50992     } catch (...) {
50993       {
50994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50995       };
50996     }
50997   }
50998   jresult = result;
50999   return jresult;
51000 }
51001
51002
51003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ImageSignal_GetConnectionCount(void * jarg1) {
51004   unsigned long jresult ;
51005   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51006   std::size_t result;
51007
51008   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51009   {
51010     try {
51011       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
51012     } catch (std::out_of_range& e) {
51013       {
51014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51015       };
51016     } catch (std::exception& e) {
51017       {
51018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51019       };
51020     } catch (...) {
51021       {
51022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51023       };
51024     }
51025   }
51026   jresult = (unsigned long)result;
51027   return jresult;
51028 }
51029
51030
51031 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Connect(void * jarg1, void * jarg2) {
51032   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51033   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51034
51035   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51036   arg2 = (void (*)(Dali::Image))jarg2;
51037   {
51038     try {
51039       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
51040     } catch (std::out_of_range& e) {
51041       {
51042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51043       };
51044     } catch (std::exception& e) {
51045       {
51046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51047       };
51048     } catch (...) {
51049       {
51050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51051       };
51052     }
51053   }
51054 }
51055
51056
51057 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
51058   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51059   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51060
51061   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51062   arg2 = (void (*)(Dali::Image))jarg2;
51063   {
51064     try {
51065       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
51066     } catch (std::out_of_range& e) {
51067       {
51068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51069       };
51070     } catch (std::exception& e) {
51071       {
51072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51073       };
51074     } catch (...) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51077       };
51078     }
51079   }
51080 }
51081
51082
51083 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Emit(void * jarg1, void * jarg2) {
51084   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51085   Dali::Image arg2 ;
51086   Dali::Image *argp2 ;
51087
51088   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51089   argp2 = (Dali::Image *)jarg2;
51090   if (!argp2) {
51091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
51092     return ;
51093   }
51094   arg2 = *argp2;
51095   {
51096     try {
51097       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
51098     } catch (std::out_of_range& e) {
51099       {
51100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51101       };
51102     } catch (std::exception& e) {
51103       {
51104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51105       };
51106     } catch (...) {
51107       {
51108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51109       };
51110     }
51111   }
51112 }
51113
51114
51115 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageSignal() {
51116   void * jresult ;
51117   Dali::Signal< void (Dali::Image) > *result = 0 ;
51118
51119   {
51120     try {
51121       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
51122     } catch (std::out_of_range& e) {
51123       {
51124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51125       };
51126     } catch (std::exception& e) {
51127       {
51128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51129       };
51130     } catch (...) {
51131       {
51132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51133       };
51134     }
51135   }
51136   jresult = (void *)result;
51137   return jresult;
51138 }
51139
51140
51141 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageSignal(void * jarg1) {
51142   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51143
51144   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51145   {
51146     try {
51147       delete arg1;
51148     } catch (std::out_of_range& e) {
51149       {
51150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51151       };
51152     } catch (std::exception& e) {
51153       {
51154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51155       };
51156     } catch (...) {
51157       {
51158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51159       };
51160     }
51161   }
51162 }
51163
51164
51165 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskSignal() {
51166   void * jresult ;
51167   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51168
51169   {
51170     try {
51171       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51172     } catch (std::out_of_range& e) {
51173       {
51174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51175       };
51176     } catch (std::exception& e) {
51177       {
51178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51179       };
51180     } catch (...) {
51181       {
51182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51183       };
51184     }
51185   }
51186   jresult = (void *)result;
51187   return jresult;
51188 }
51189
51190
51191 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTaskSignal(void * jarg1) {
51192   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51193
51194   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51195   {
51196     try {
51197       delete arg1;
51198     } catch (std::out_of_range& e) {
51199       {
51200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51201       };
51202     } catch (std::exception& e) {
51203       {
51204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51205       };
51206     } catch (...) {
51207       {
51208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51209       };
51210     }
51211   }
51212 }
51213
51214
51215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51216   unsigned int jresult ;
51217   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51218   bool result;
51219
51220   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51221   {
51222     try {
51223       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);
51224     } catch (std::out_of_range& e) {
51225       {
51226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51227       };
51228     } catch (std::exception& e) {
51229       {
51230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51231       };
51232     } catch (...) {
51233       {
51234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51235       };
51236     }
51237   }
51238   jresult = result;
51239   return jresult;
51240 }
51241
51242
51243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51244   unsigned long jresult ;
51245   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51246   std::size_t result;
51247
51248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51249   {
51250     try {
51251       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);
51252     } catch (std::out_of_range& e) {
51253       {
51254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51255       };
51256     } catch (std::exception& e) {
51257       {
51258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51259       };
51260     } catch (...) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51263       };
51264     }
51265   }
51266   jresult = (unsigned long)result;
51267   return jresult;
51268 }
51269
51270
51271 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51272   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51273   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51274
51275   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51276   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51277   {
51278     try {
51279       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51280     } catch (std::out_of_range& e) {
51281       {
51282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (std::exception& e) {
51285       {
51286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51287       };
51288     } catch (...) {
51289       {
51290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51291       };
51292     }
51293   }
51294 }
51295
51296
51297 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51298   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51299   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51300
51301   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51302   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51303   {
51304     try {
51305       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51306     } catch (std::out_of_range& e) {
51307       {
51308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51309       };
51310     } catch (std::exception& e) {
51311       {
51312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51313       };
51314     } catch (...) {
51315       {
51316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51317       };
51318     }
51319   }
51320 }
51321
51322
51323 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51324   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51325   Dali::Actor arg2 ;
51326   Dali::LongPressGesture *arg3 = 0 ;
51327   Dali::Actor *argp2 ;
51328
51329   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51330   argp2 = (Dali::Actor *)jarg2;
51331   if (!argp2) {
51332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51333     return ;
51334   }
51335   arg2 = *argp2;
51336   arg3 = (Dali::LongPressGesture *)jarg3;
51337   if (!arg3) {
51338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51339     return ;
51340   }
51341   {
51342     try {
51343       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51344     } catch (std::out_of_range& e) {
51345       {
51346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51347       };
51348     } catch (std::exception& e) {
51349       {
51350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51351       };
51352     } catch (...) {
51353       {
51354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51355       };
51356     }
51357   }
51358 }
51359
51360
51361 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetectedSignal() {
51362   void * jresult ;
51363   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51364
51365   {
51366     try {
51367       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51368     } catch (std::out_of_range& e) {
51369       {
51370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51371       };
51372     } catch (std::exception& e) {
51373       {
51374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51375       };
51376     } catch (...) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51379       };
51380     }
51381   }
51382   jresult = (void *)result;
51383   return jresult;
51384 }
51385
51386
51387 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGestureDetectedSignal(void * jarg1) {
51388   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51389
51390   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51391   {
51392     try {
51393       delete arg1;
51394     } catch (std::out_of_range& e) {
51395       {
51396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51397       };
51398     } catch (std::exception& e) {
51399       {
51400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51401       };
51402     } catch (...) {
51403       {
51404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51405       };
51406     }
51407   }
51408 }
51409
51410
51411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Empty(void * jarg1) {
51412   unsigned int jresult ;
51413   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51414   bool result;
51415
51416   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51417   {
51418     try {
51419       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);
51420     } catch (std::out_of_range& e) {
51421       {
51422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51423       };
51424     } catch (std::exception& e) {
51425       {
51426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51427       };
51428     } catch (...) {
51429       {
51430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51431       };
51432     }
51433   }
51434   jresult = result;
51435   return jresult;
51436 }
51437
51438
51439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51440   unsigned long jresult ;
51441   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51442   std::size_t result;
51443
51444   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51445   {
51446     try {
51447       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);
51448     } catch (std::out_of_range& e) {
51449       {
51450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51451       };
51452     } catch (std::exception& e) {
51453       {
51454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51455       };
51456     } catch (...) {
51457       {
51458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51459       };
51460     }
51461   }
51462   jresult = (unsigned long)result;
51463   return jresult;
51464 }
51465
51466
51467 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51468   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51469   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51470
51471   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51472   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51473   {
51474     try {
51475       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51476     } catch (std::out_of_range& e) {
51477       {
51478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51479       };
51480     } catch (std::exception& e) {
51481       {
51482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51483       };
51484     } catch (...) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51487       };
51488     }
51489   }
51490 }
51491
51492
51493 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51494   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51495   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51496
51497   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51498   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51499   {
51500     try {
51501       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51502     } catch (std::out_of_range& e) {
51503       {
51504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (std::exception& e) {
51507       {
51508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51509       };
51510     } catch (...) {
51511       {
51512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51513       };
51514     }
51515   }
51516 }
51517
51518
51519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51520   unsigned int jresult ;
51521   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51522   Dali::Actor arg2 ;
51523   Dali::TouchData *arg3 = 0 ;
51524   Dali::Actor *argp2 ;
51525   bool result;
51526
51527   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51528   argp2 = (Dali::Actor *)jarg2;
51529   if (!argp2) {
51530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51531     return 0;
51532   }
51533   arg2 = *argp2;
51534   arg3 = (Dali::TouchData *)jarg3;
51535   if (!arg3) {
51536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51537     return 0;
51538   }
51539   {
51540     try {
51541       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51542     } catch (std::out_of_range& e) {
51543       {
51544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51545       };
51546     } catch (std::exception& e) {
51547       {
51548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51549       };
51550     } catch (...) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51553       };
51554     }
51555   }
51556   jresult = result;
51557   return jresult;
51558 }
51559
51560
51561 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorTouchDataSignal() {
51562   void * jresult ;
51563   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51564
51565   {
51566     try {
51567       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (...) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51579       };
51580     }
51581   }
51582   jresult = (void *)result;
51583   return jresult;
51584 }
51585
51586
51587 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorTouchDataSignal(void * jarg1) {
51588   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51589
51590   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51591   {
51592     try {
51593       delete arg1;
51594     } catch (std::out_of_range& e) {
51595       {
51596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51597       };
51598     } catch (std::exception& e) {
51599       {
51600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51601       };
51602     } catch (...) {
51603       {
51604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51605       };
51606     }
51607   }
51608 }
51609
51610
51611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Empty(void * jarg1) {
51612   unsigned int jresult ;
51613   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51614   bool result;
51615
51616   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51617   {
51618     try {
51619       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);
51620     } catch (std::out_of_range& e) {
51621       {
51622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51623       };
51624     } catch (std::exception& e) {
51625       {
51626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51627       };
51628     } catch (...) {
51629       {
51630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51631       };
51632     }
51633   }
51634   jresult = result;
51635   return jresult;
51636 }
51637
51638
51639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_GetConnectionCount(void * jarg1) {
51640   unsigned long jresult ;
51641   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51642   std::size_t result;
51643
51644   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51645   {
51646     try {
51647       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);
51648     } catch (std::out_of_range& e) {
51649       {
51650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51651       };
51652     } catch (std::exception& e) {
51653       {
51654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51655       };
51656     } catch (...) {
51657       {
51658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51659       };
51660     }
51661   }
51662   jresult = (unsigned long)result;
51663   return jresult;
51664 }
51665
51666
51667 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Connect(void * jarg1, void * jarg2) {
51668   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51669   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51670
51671   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51672   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51673   {
51674     try {
51675       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51676     } catch (std::out_of_range& e) {
51677       {
51678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51679       };
51680     } catch (std::exception& e) {
51681       {
51682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51687       };
51688     }
51689   }
51690 }
51691
51692
51693 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Disconnect(void * jarg1, void * jarg2) {
51694   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51695   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51696
51697   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51698   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51699   {
51700     try {
51701       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51702     } catch (std::out_of_range& e) {
51703       {
51704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51705       };
51706     } catch (std::exception& e) {
51707       {
51708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51709       };
51710     } catch (...) {
51711       {
51712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51713       };
51714     }
51715   }
51716 }
51717
51718
51719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51720   unsigned int jresult ;
51721   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51722   Dali::Actor arg2 ;
51723   Dali::HoverEvent *arg3 = 0 ;
51724   Dali::Actor *argp2 ;
51725   bool result;
51726
51727   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51728   argp2 = (Dali::Actor *)jarg2;
51729   if (!argp2) {
51730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51731     return 0;
51732   }
51733   arg2 = *argp2;
51734   arg3 = (Dali::HoverEvent *)jarg3;
51735   if (!arg3) {
51736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51737     return 0;
51738   }
51739   {
51740     try {
51741       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51742     } catch (std::out_of_range& e) {
51743       {
51744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51745       };
51746     } catch (std::exception& e) {
51747       {
51748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51749       };
51750     } catch (...) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51753       };
51754     }
51755   }
51756   jresult = result;
51757   return jresult;
51758 }
51759
51760
51761 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorHoverEventSignal() {
51762   void * jresult ;
51763   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
51764
51765   {
51766     try {
51767       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
51768     } catch (std::out_of_range& e) {
51769       {
51770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51771       };
51772     } catch (std::exception& e) {
51773       {
51774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51775       };
51776     } catch (...) {
51777       {
51778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51779       };
51780     }
51781   }
51782   jresult = (void *)result;
51783   return jresult;
51784 }
51785
51786
51787 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorHoverEventSignal(void * jarg1) {
51788   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51789
51790   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51791   {
51792     try {
51793       delete arg1;
51794     } catch (std::out_of_range& e) {
51795       {
51796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51797       };
51798     } catch (std::exception& e) {
51799       {
51800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51801       };
51802     } catch (...) {
51803       {
51804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51805       };
51806     }
51807   }
51808 }
51809
51810
51811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Empty(void * jarg1) {
51812   unsigned int jresult ;
51813   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51814   bool result;
51815
51816   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51817   {
51818     try {
51819       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);
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834   jresult = result;
51835   return jresult;
51836 }
51837
51838
51839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_GetConnectionCount(void * jarg1) {
51840   unsigned long jresult ;
51841   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51842   std::size_t result;
51843
51844   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51845   {
51846     try {
51847       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);
51848     } catch (std::out_of_range& e) {
51849       {
51850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51851       };
51852     } catch (std::exception& e) {
51853       {
51854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51855       };
51856     } catch (...) {
51857       {
51858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51859       };
51860     }
51861   }
51862   jresult = (unsigned long)result;
51863   return jresult;
51864 }
51865
51866
51867 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Connect(void * jarg1, void * jarg2) {
51868   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51869   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51870
51871   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51872   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51873   {
51874     try {
51875       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51876     } catch (std::out_of_range& e) {
51877       {
51878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51879       };
51880     } catch (std::exception& e) {
51881       {
51882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51883       };
51884     } catch (...) {
51885       {
51886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51887       };
51888     }
51889   }
51890 }
51891
51892
51893 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
51894   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51895   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51896
51897   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51898   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51899   {
51900     try {
51901       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51902     } catch (std::out_of_range& e) {
51903       {
51904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51905       };
51906     } catch (std::exception& e) {
51907       {
51908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51909       };
51910     } catch (...) {
51911       {
51912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51913       };
51914     }
51915   }
51916 }
51917
51918
51919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51920   unsigned int jresult ;
51921   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51922   Dali::Actor arg2 ;
51923   Dali::WheelEvent *arg3 = 0 ;
51924   Dali::Actor *argp2 ;
51925   bool result;
51926
51927   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51928   argp2 = (Dali::Actor *)jarg2;
51929   if (!argp2) {
51930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51931     return 0;
51932   }
51933   arg2 = *argp2;
51934   arg3 = (Dali::WheelEvent *)jarg3;
51935   if (!arg3) {
51936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51937     return 0;
51938   }
51939   {
51940     try {
51941       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
51942     } catch (std::out_of_range& e) {
51943       {
51944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (std::exception& e) {
51947       {
51948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51949       };
51950     } catch (...) {
51951       {
51952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51953       };
51954     }
51955   }
51956   jresult = result;
51957   return jresult;
51958 }
51959
51960
51961 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorWheelEventSignal() {
51962   void * jresult ;
51963   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
51964
51965   {
51966     try {
51967       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
51968     } catch (std::out_of_range& e) {
51969       {
51970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51971       };
51972     } catch (std::exception& e) {
51973       {
51974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51975       };
51976     } catch (...) {
51977       {
51978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51979       };
51980     }
51981   }
51982   jresult = (void *)result;
51983   return jresult;
51984 }
51985
51986
51987 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorWheelEventSignal(void * jarg1) {
51988   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51989
51990   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51991   {
51992     try {
51993       delete arg1;
51994     } catch (std::out_of_range& e) {
51995       {
51996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51997       };
51998     } catch (std::exception& e) {
51999       {
52000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52001       };
52002     } catch (...) {
52003       {
52004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52005       };
52006     }
52007   }
52008 }
52009
52010
52011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorSignal_Empty(void * jarg1) {
52012   unsigned int jresult ;
52013   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52014   bool result;
52015
52016   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52017   {
52018     try {
52019       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52020     } catch (std::out_of_range& e) {
52021       {
52022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52023       };
52024     } catch (std::exception& e) {
52025       {
52026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52027       };
52028     } catch (...) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52031       };
52032     }
52033   }
52034   jresult = result;
52035   return jresult;
52036 }
52037
52038
52039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorSignal_GetConnectionCount(void * jarg1) {
52040   unsigned long jresult ;
52041   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52042   std::size_t result;
52043
52044   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52045   {
52046     try {
52047       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52048     } catch (std::out_of_range& e) {
52049       {
52050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52051       };
52052     } catch (std::exception& e) {
52053       {
52054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52055       };
52056     } catch (...) {
52057       {
52058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52059       };
52060     }
52061   }
52062   jresult = (unsigned long)result;
52063   return jresult;
52064 }
52065
52066
52067 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Connect(void * jarg1, void * jarg2) {
52068   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52069   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52070
52071   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52072   arg2 = (void (*)(Dali::Actor))jarg2;
52073   {
52074     try {
52075       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52076     } catch (std::out_of_range& e) {
52077       {
52078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52079       };
52080     } catch (std::exception& e) {
52081       {
52082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52083       };
52084     } catch (...) {
52085       {
52086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52087       };
52088     }
52089   }
52090 }
52091
52092
52093 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52094   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52095   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52096
52097   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52098   arg2 = (void (*)(Dali::Actor))jarg2;
52099   {
52100     try {
52101       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52102     } catch (std::out_of_range& e) {
52103       {
52104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52105       };
52106     } catch (std::exception& e) {
52107       {
52108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (...) {
52111       {
52112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52113       };
52114     }
52115   }
52116 }
52117
52118
52119 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Emit(void * jarg1, void * jarg2) {
52120   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52121   Dali::Actor arg2 ;
52122   Dali::Actor *argp2 ;
52123
52124   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52125   argp2 = (Dali::Actor *)jarg2;
52126   if (!argp2) {
52127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52128     return ;
52129   }
52130   arg2 = *argp2;
52131   {
52132     try {
52133       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52134     } catch (std::out_of_range& e) {
52135       {
52136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52137       };
52138     } catch (std::exception& e) {
52139       {
52140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52141       };
52142     } catch (...) {
52143       {
52144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52145       };
52146     }
52147   }
52148 }
52149
52150
52151 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorSignal() {
52152   void * jresult ;
52153   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52154
52155   {
52156     try {
52157       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52158     } catch (std::out_of_range& e) {
52159       {
52160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52161       };
52162     } catch (std::exception& e) {
52163       {
52164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52165       };
52166     } catch (...) {
52167       {
52168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52169       };
52170     }
52171   }
52172   jresult = (void *)result;
52173   return jresult;
52174 }
52175
52176
52177 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorSignal(void * jarg1) {
52178   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52179
52180   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52181   {
52182     try {
52183       delete arg1;
52184     } catch (std::out_of_range& e) {
52185       {
52186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (std::exception& e) {
52189       {
52190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (...) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52195       };
52196     }
52197   }
52198 }
52199
52200
52201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEventSignal_Empty(void * jarg1) {
52202   unsigned int jresult ;
52203   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52204   bool result;
52205
52206   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52207   {
52208     try {
52209       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52210     } catch (std::out_of_range& e) {
52211       {
52212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52213       };
52214     } catch (std::exception& e) {
52215       {
52216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52217       };
52218     } catch (...) {
52219       {
52220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52221       };
52222     }
52223   }
52224   jresult = result;
52225   return jresult;
52226 }
52227
52228
52229 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyEventSignal_GetConnectionCount(void * jarg1) {
52230   unsigned long jresult ;
52231   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52232   std::size_t result;
52233
52234   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52235   {
52236     try {
52237       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52238     } catch (std::out_of_range& e) {
52239       {
52240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52241       };
52242     } catch (std::exception& e) {
52243       {
52244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52245       };
52246     } catch (...) {
52247       {
52248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52249       };
52250     }
52251   }
52252   jresult = (unsigned long)result;
52253   return jresult;
52254 }
52255
52256
52257 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52258   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52259   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52260
52261   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52262   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52263   {
52264     try {
52265       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52266     } catch (std::out_of_range& e) {
52267       {
52268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52269       };
52270     } catch (std::exception& e) {
52271       {
52272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52273       };
52274     } catch (...) {
52275       {
52276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52277       };
52278     }
52279   }
52280 }
52281
52282
52283 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52284   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52285   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52286
52287   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52288   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52289   {
52290     try {
52291       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52292     } catch (std::out_of_range& e) {
52293       {
52294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52295       };
52296     } catch (std::exception& e) {
52297       {
52298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52303       };
52304     }
52305   }
52306 }
52307
52308
52309 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52310   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52311   Dali::KeyEvent *arg2 = 0 ;
52312
52313   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52314   arg2 = (Dali::KeyEvent *)jarg2;
52315   if (!arg2) {
52316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52317     return ;
52318   }
52319   {
52320     try {
52321       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52329       };
52330     } catch (...) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52333       };
52334     }
52335   }
52336 }
52337
52338
52339 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEventSignal() {
52340   void * jresult ;
52341   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52342
52343   {
52344     try {
52345       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52346     } catch (std::out_of_range& e) {
52347       {
52348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52349       };
52350     } catch (std::exception& e) {
52351       {
52352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52353       };
52354     } catch (...) {
52355       {
52356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52357       };
52358     }
52359   }
52360   jresult = (void *)result;
52361   return jresult;
52362 }
52363
52364
52365 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyEventSignal(void * jarg1) {
52366   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52367
52368   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52369   {
52370     try {
52371       delete arg1;
52372     } catch (std::out_of_range& e) {
52373       {
52374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52375       };
52376     } catch (std::exception& e) {
52377       {
52378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52379       };
52380     } catch (...) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52383       };
52384     }
52385   }
52386 }
52387
52388
52389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TouchSignal_Empty(void * jarg1) {
52390   unsigned int jresult ;
52391   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52392   bool result;
52393
52394   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52395   {
52396     try {
52397       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52398     } catch (std::out_of_range& e) {
52399       {
52400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52401       };
52402     } catch (std::exception& e) {
52403       {
52404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52405       };
52406     } catch (...) {
52407       {
52408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52409       };
52410     }
52411   }
52412   jresult = result;
52413   return jresult;
52414 }
52415
52416
52417 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchSignal_GetConnectionCount(void * jarg1) {
52418   unsigned long jresult ;
52419   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52420   std::size_t result;
52421
52422   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52423   {
52424     try {
52425       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (...) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52437       };
52438     }
52439   }
52440   jresult = (unsigned long)result;
52441   return jresult;
52442 }
52443
52444
52445 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Connect(void * jarg1, void * jarg2) {
52446   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52447   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52448
52449   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52450   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52451   {
52452     try {
52453       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52454     } catch (std::out_of_range& e) {
52455       {
52456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52457       };
52458     } catch (std::exception& e) {
52459       {
52460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52461       };
52462     } catch (...) {
52463       {
52464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52465       };
52466     }
52467   }
52468 }
52469
52470
52471 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52472   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52473   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52474
52475   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52476   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52477   {
52478     try {
52479       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52480     } catch (std::out_of_range& e) {
52481       {
52482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52483       };
52484     } catch (std::exception& e) {
52485       {
52486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52487       };
52488     } catch (...) {
52489       {
52490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52491       };
52492     }
52493   }
52494 }
52495
52496
52497 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Emit(void * jarg1, void * jarg2) {
52498   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52499   Dali::TouchData *arg2 = 0 ;
52500
52501   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52502   arg2 = (Dali::TouchData *)jarg2;
52503   if (!arg2) {
52504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52505     return ;
52506   }
52507   {
52508     try {
52509       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52510     } catch (std::out_of_range& e) {
52511       {
52512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52513       };
52514     } catch (std::exception& e) {
52515       {
52516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52517       };
52518     } catch (...) {
52519       {
52520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52521       };
52522     }
52523   }
52524 }
52525
52526
52527 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchSignal() {
52528   void * jresult ;
52529   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52530
52531   {
52532     try {
52533       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52534     } catch (std::out_of_range& e) {
52535       {
52536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (std::exception& e) {
52539       {
52540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52541       };
52542     } catch (...) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52545       };
52546     }
52547   }
52548   jresult = (void *)result;
52549   return jresult;
52550 }
52551
52552
52553 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchSignal(void * jarg1) {
52554   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52555
52556   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52557   {
52558     try {
52559       delete arg1;
52560     } catch (std::out_of_range& e) {
52561       {
52562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52563       };
52564     } catch (std::exception& e) {
52565       {
52566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52567       };
52568     } catch (...) {
52569       {
52570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52571       };
52572     }
52573   }
52574 }
52575
52576
52577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Empty(void * jarg1) {
52578   unsigned int jresult ;
52579   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52580   bool result;
52581
52582   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52583   {
52584     try {
52585       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52586     } catch (std::out_of_range& e) {
52587       {
52588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52589       };
52590     } catch (std::exception& e) {
52591       {
52592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52593       };
52594     } catch (...) {
52595       {
52596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52597       };
52598     }
52599   }
52600   jresult = result;
52601   return jresult;
52602 }
52603
52604
52605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_GetConnectionCount(void * jarg1) {
52606   unsigned long jresult ;
52607   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52608   std::size_t result;
52609
52610   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52611   {
52612     try {
52613       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52614     } catch (std::out_of_range& e) {
52615       {
52616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52617       };
52618     } catch (std::exception& e) {
52619       {
52620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52621       };
52622     } catch (...) {
52623       {
52624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52625       };
52626     }
52627   }
52628   jresult = (unsigned long)result;
52629   return jresult;
52630 }
52631
52632
52633 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Connect(void * jarg1, void * jarg2) {
52634   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52635   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52636
52637   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52638   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52639   {
52640     try {
52641       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52642     } catch (std::out_of_range& e) {
52643       {
52644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52645       };
52646     } catch (std::exception& e) {
52647       {
52648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52649       };
52650     } catch (...) {
52651       {
52652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52653       };
52654     }
52655   }
52656 }
52657
52658
52659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
52660   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52661   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52662
52663   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52664   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52665   {
52666     try {
52667       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52668     } catch (std::out_of_range& e) {
52669       {
52670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52671       };
52672     } catch (std::exception& e) {
52673       {
52674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52675       };
52676     } catch (...) {
52677       {
52678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52679       };
52680     }
52681   }
52682 }
52683
52684
52685 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Emit(void * jarg1, void * jarg2) {
52686   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52687   Dali::WheelEvent *arg2 = 0 ;
52688
52689   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52690   arg2 = (Dali::WheelEvent *)jarg2;
52691   if (!arg2) {
52692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52693     return ;
52694   }
52695   {
52696     try {
52697       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
52698     } catch (std::out_of_range& e) {
52699       {
52700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52701       };
52702     } catch (std::exception& e) {
52703       {
52704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (...) {
52707       {
52708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52709       };
52710     }
52711   }
52712 }
52713
52714
52715 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StageWheelEventSignal() {
52716   void * jresult ;
52717   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
52718
52719   {
52720     try {
52721       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
52722     } catch (std::out_of_range& e) {
52723       {
52724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52725       };
52726     } catch (std::exception& e) {
52727       {
52728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52729       };
52730     } catch (...) {
52731       {
52732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52733       };
52734     }
52735   }
52736   jresult = (void *)result;
52737   return jresult;
52738 }
52739
52740
52741 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StageWheelEventSignal(void * jarg1) {
52742   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52743
52744   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52745   {
52746     try {
52747       delete arg1;
52748     } catch (std::out_of_range& e) {
52749       {
52750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52751       };
52752     } catch (std::exception& e) {
52753       {
52754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52755       };
52756     } catch (...) {
52757       {
52758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52759       };
52760     }
52761   }
52762 }
52763
52764
52765 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_0() {
52766   void * jresult ;
52767   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52768
52769   {
52770     try {
52771       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
52772     } catch (std::out_of_range& e) {
52773       {
52774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52775       };
52776     } catch (std::exception& e) {
52777       {
52778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52779       };
52780     } catch (...) {
52781       {
52782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52783       };
52784     }
52785   }
52786   jresult = (void *)result;
52787   return jresult;
52788 }
52789
52790
52791 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
52792   void * jresult ;
52793   Dali::Radian arg1 ;
52794   Dali::Radian arg2 ;
52795   Dali::Radian *argp1 ;
52796   Dali::Radian *argp2 ;
52797   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52798
52799   argp1 = (Dali::Radian *)jarg1;
52800   if (!argp1) {
52801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52802     return 0;
52803   }
52804   arg1 = *argp1;
52805   argp2 = (Dali::Radian *)jarg2;
52806   if (!argp2) {
52807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52808     return 0;
52809   }
52810   arg2 = *argp2;
52811   {
52812     try {
52813       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
52814     } catch (std::out_of_range& e) {
52815       {
52816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52817       };
52818     } catch (std::exception& e) {
52819       {
52820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52821       };
52822     } catch (...) {
52823       {
52824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52825       };
52826     }
52827   }
52828   jresult = (void *)result;
52829   return jresult;
52830 }
52831
52832
52833 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_2(void * jarg1) {
52834   void * jresult ;
52835   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
52836   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52837
52838   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52839   if (!arg1) {
52840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
52841     return 0;
52842   }
52843   {
52844     try {
52845       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
52846     } catch (std::out_of_range& e) {
52847       {
52848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52849       };
52850     } catch (std::exception& e) {
52851       {
52852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52853       };
52854     } catch (...) {
52855       {
52856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52857       };
52858     }
52859   }
52860   jresult = (void *)result;
52861   return jresult;
52862 }
52863
52864
52865 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
52866   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52867   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52868
52869   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52870   arg2 = (Dali::Radian *)jarg2;
52871   if (arg1) (arg1)->first = *arg2;
52872 }
52873
52874
52875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleThresholdPair_first_get(void * jarg1) {
52876   void * jresult ;
52877   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52878   Dali::Radian *result = 0 ;
52879
52880   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52881   result = (Dali::Radian *)& ((arg1)->first);
52882   jresult = (void *)result;
52883   return jresult;
52884 }
52885
52886
52887 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
52888   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52889   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52890
52891   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52892   arg2 = (Dali::Radian *)jarg2;
52893   if (arg1) (arg1)->second = *arg2;
52894 }
52895
52896
52897 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleThresholdPair_second_get(void * jarg1) {
52898   void * jresult ;
52899   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52900   Dali::Radian *result = 0 ;
52901
52902   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52903   result = (Dali::Radian *)& ((arg1)->second);
52904   jresult = (void *)result;
52905   return jresult;
52906 }
52907
52908
52909 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AngleThresholdPair(void * jarg1) {
52910   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52911
52912   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52913   {
52914     try {
52915       delete arg1;
52916     } catch (std::out_of_range& e) {
52917       {
52918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52919       };
52920     } catch (std::exception& e) {
52921       {
52922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52923       };
52924     } catch (...) {
52925       {
52926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52927       };
52928     }
52929   }
52930 }
52931
52932
52933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Empty(void * jarg1) {
52934   unsigned int jresult ;
52935   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52936   bool result;
52937
52938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52939   {
52940     try {
52941       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);
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52949       };
52950     } catch (...) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52953       };
52954     }
52955   }
52956   jresult = result;
52957   return jresult;
52958 }
52959
52960
52961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52962   unsigned long jresult ;
52963   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52964   std::size_t result;
52965
52966   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52967   {
52968     try {
52969       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);
52970     } catch (std::out_of_range& e) {
52971       {
52972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (std::exception& e) {
52975       {
52976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52981       };
52982     }
52983   }
52984   jresult = (unsigned long)result;
52985   return jresult;
52986 }
52987
52988
52989 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52990   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52991   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
52992
52993   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52994   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
52995   {
52996     try {
52997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (...) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53009       };
53010     }
53011   }
53012 }
53013
53014
53015 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53016   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53017   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53018
53019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53020   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53021   {
53022     try {
53023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53024     } catch (std::out_of_range& e) {
53025       {
53026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53027       };
53028     } catch (std::exception& e) {
53029       {
53030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53031       };
53032     } catch (...) {
53033       {
53034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53035       };
53036     }
53037   }
53038 }
53039
53040
53041 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53042   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53043   Dali::Actor arg2 ;
53044   Dali::PanGesture *arg3 = 0 ;
53045   Dali::Actor *argp2 ;
53046
53047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53048   argp2 = (Dali::Actor *)jarg2;
53049   if (!argp2) {
53050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53051     return ;
53052   }
53053   arg2 = *argp2;
53054   arg3 = (Dali::PanGesture *)jarg3;
53055   if (!arg3) {
53056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53057     return ;
53058   }
53059   {
53060     try {
53061       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53062     } catch (std::out_of_range& e) {
53063       {
53064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53065       };
53066     } catch (std::exception& e) {
53067       {
53068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53069       };
53070     } catch (...) {
53071       {
53072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53073       };
53074     }
53075   }
53076 }
53077
53078
53079 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetectedSignal() {
53080   void * jresult ;
53081   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53082
53083   {
53084     try {
53085       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53086     } catch (std::out_of_range& e) {
53087       {
53088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53089       };
53090     } catch (std::exception& e) {
53091       {
53092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53093       };
53094     } catch (...) {
53095       {
53096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53097       };
53098     }
53099   }
53100   jresult = (void *)result;
53101   return jresult;
53102 }
53103
53104
53105 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetectedSignal(void * jarg1) {
53106   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53107
53108   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53109   {
53110     try {
53111       delete arg1;
53112     } catch (std::out_of_range& e) {
53113       {
53114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53115       };
53116     } catch (std::exception& e) {
53117       {
53118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53119       };
53120     } catch (...) {
53121       {
53122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53123       };
53124     }
53125   }
53126 }
53127
53128
53129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Empty(void * jarg1) {
53130   unsigned int jresult ;
53131   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53132   bool result;
53133
53134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53135   {
53136     try {
53137       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);
53138     } catch (std::out_of_range& e) {
53139       {
53140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53141       };
53142     } catch (std::exception& e) {
53143       {
53144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53145       };
53146     } catch (...) {
53147       {
53148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53149       };
53150     }
53151   }
53152   jresult = result;
53153   return jresult;
53154 }
53155
53156
53157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53158   unsigned long jresult ;
53159   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53160   std::size_t result;
53161
53162   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53163   {
53164     try {
53165       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);
53166     } catch (std::out_of_range& e) {
53167       {
53168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53169       };
53170     } catch (std::exception& e) {
53171       {
53172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53173       };
53174     } catch (...) {
53175       {
53176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53177       };
53178     }
53179   }
53180   jresult = (unsigned long)result;
53181   return jresult;
53182 }
53183
53184
53185 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53186   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53187   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53188
53189   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53190   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53191   {
53192     try {
53193       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53194     } catch (std::out_of_range& e) {
53195       {
53196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53197       };
53198     } catch (std::exception& e) {
53199       {
53200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53201       };
53202     } catch (...) {
53203       {
53204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53205       };
53206     }
53207   }
53208 }
53209
53210
53211 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53212   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53213   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53214
53215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53216   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53217   {
53218     try {
53219       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53220     } catch (std::out_of_range& e) {
53221       {
53222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53223       };
53224     } catch (std::exception& e) {
53225       {
53226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53227       };
53228     } catch (...) {
53229       {
53230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53231       };
53232     }
53233   }
53234 }
53235
53236
53237 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53238   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53239   Dali::Actor arg2 ;
53240   Dali::PinchGesture *arg3 = 0 ;
53241   Dali::Actor *argp2 ;
53242
53243   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53244   argp2 = (Dali::Actor *)jarg2;
53245   if (!argp2) {
53246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53247     return ;
53248   }
53249   arg2 = *argp2;
53250   arg3 = (Dali::PinchGesture *)jarg3;
53251   if (!arg3) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53253     return ;
53254   }
53255   {
53256     try {
53257       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53258     } catch (std::out_of_range& e) {
53259       {
53260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (std::exception& e) {
53263       {
53264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (...) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53269       };
53270     }
53271   }
53272 }
53273
53274
53275 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetectedSignal() {
53276   void * jresult ;
53277   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53278
53279   {
53280     try {
53281       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53282     } catch (std::out_of_range& e) {
53283       {
53284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53285       };
53286     } catch (std::exception& e) {
53287       {
53288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53289       };
53290     } catch (...) {
53291       {
53292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53293       };
53294     }
53295   }
53296   jresult = (void *)result;
53297   return jresult;
53298 }
53299
53300
53301 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGestureDetectedSignal(void * jarg1) {
53302   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53303
53304   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53305   {
53306     try {
53307       delete arg1;
53308     } catch (std::out_of_range& e) {
53309       {
53310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53311       };
53312     } catch (std::exception& e) {
53313       {
53314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53315       };
53316     } catch (...) {
53317       {
53318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53319       };
53320     }
53321   }
53322 }
53323
53324
53325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Empty(void * jarg1) {
53326   unsigned int jresult ;
53327   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53328   bool result;
53329
53330   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53331   {
53332     try {
53333       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);
53334     } catch (std::out_of_range& e) {
53335       {
53336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53337       };
53338     } catch (std::exception& e) {
53339       {
53340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53341       };
53342     } catch (...) {
53343       {
53344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53345       };
53346     }
53347   }
53348   jresult = result;
53349   return jresult;
53350 }
53351
53352
53353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53354   unsigned long jresult ;
53355   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53356   std::size_t result;
53357
53358   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53359   {
53360     try {
53361       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);
53362     } catch (std::out_of_range& e) {
53363       {
53364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53365       };
53366     } catch (std::exception& e) {
53367       {
53368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53369       };
53370     } catch (...) {
53371       {
53372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53373       };
53374     }
53375   }
53376   jresult = (unsigned long)result;
53377   return jresult;
53378 }
53379
53380
53381 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53382   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53383   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53384
53385   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53386   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53387   {
53388     try {
53389       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53390     } catch (std::out_of_range& e) {
53391       {
53392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53393       };
53394     } catch (std::exception& e) {
53395       {
53396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53397       };
53398     } catch (...) {
53399       {
53400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53401       };
53402     }
53403   }
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53408   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53409   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53410
53411   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53412   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53413   {
53414     try {
53415       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53416     } catch (std::out_of_range& e) {
53417       {
53418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53419       };
53420     } catch (std::exception& e) {
53421       {
53422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53423       };
53424     } catch (...) {
53425       {
53426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53427       };
53428     }
53429   }
53430 }
53431
53432
53433 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53434   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53435   Dali::Actor arg2 ;
53436   Dali::TapGesture *arg3 = 0 ;
53437   Dali::Actor *argp2 ;
53438
53439   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53440   argp2 = (Dali::Actor *)jarg2;
53441   if (!argp2) {
53442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53443     return ;
53444   }
53445   arg2 = *argp2;
53446   arg3 = (Dali::TapGesture *)jarg3;
53447   if (!arg3) {
53448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53449     return ;
53450   }
53451   {
53452     try {
53453       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
53454     } catch (std::out_of_range& e) {
53455       {
53456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53457       };
53458     } catch (std::exception& e) {
53459       {
53460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (...) {
53463       {
53464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53465       };
53466     }
53467   }
53468 }
53469
53470
53471 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetectedSignal() {
53472   void * jresult ;
53473   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
53474
53475   {
53476     try {
53477       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
53478     } catch (std::out_of_range& e) {
53479       {
53480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53481       };
53482     } catch (std::exception& e) {
53483       {
53484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53485       };
53486     } catch (...) {
53487       {
53488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53489       };
53490     }
53491   }
53492   jresult = (void *)result;
53493   return jresult;
53494 }
53495
53496
53497 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGestureDetectedSignal(void * jarg1) {
53498   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53499
53500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53501   {
53502     try {
53503       delete arg1;
53504     } catch (std::out_of_range& e) {
53505       {
53506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53507       };
53508     } catch (std::exception& e) {
53509       {
53510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53511       };
53512     } catch (...) {
53513       {
53514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53515       };
53516     }
53517   }
53518 }
53519
53520
53521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AnimationSignal_Empty(void * jarg1) {
53522   unsigned int jresult ;
53523   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53524   bool result;
53525
53526   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53527   {
53528     try {
53529       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53530     } catch (std::out_of_range& e) {
53531       {
53532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53533       };
53534     } catch (std::exception& e) {
53535       {
53536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53537       };
53538     } catch (...) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53541       };
53542     }
53543   }
53544   jresult = result;
53545   return jresult;
53546 }
53547
53548
53549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AnimationSignal_GetConnectionCount(void * jarg1) {
53550   unsigned long jresult ;
53551   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53552   std::size_t result;
53553
53554   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53555   {
53556     try {
53557       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53558     } catch (std::out_of_range& e) {
53559       {
53560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (std::exception& e) {
53563       {
53564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53565       };
53566     } catch (...) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53569       };
53570     }
53571   }
53572   jresult = (unsigned long)result;
53573   return jresult;
53574 }
53575
53576
53577 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Connect(void * jarg1, void * jarg2) {
53578   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53579   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53580
53581   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53582   arg2 = (void (*)(Dali::Animation &))jarg2;
53583   {
53584     try {
53585       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
53586     } catch (std::out_of_range& e) {
53587       {
53588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53589       };
53590     } catch (std::exception& e) {
53591       {
53592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53593       };
53594     } catch (...) {
53595       {
53596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53597       };
53598     }
53599   }
53600 }
53601
53602
53603 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
53604   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53605   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53606
53607   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53608   arg2 = (void (*)(Dali::Animation &))jarg2;
53609   {
53610     try {
53611       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
53612     } catch (std::out_of_range& e) {
53613       {
53614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53615       };
53616     } catch (std::exception& e) {
53617       {
53618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53619       };
53620     } catch (...) {
53621       {
53622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53623       };
53624     }
53625   }
53626 }
53627
53628
53629 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Emit(void * jarg1, void * jarg2) {
53630   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53631   Dali::Animation *arg2 = 0 ;
53632
53633   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53634   arg2 = (Dali::Animation *)jarg2;
53635   if (!arg2) {
53636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
53637     return ;
53638   }
53639   {
53640     try {
53641       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
53642     } catch (std::out_of_range& e) {
53643       {
53644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53645       };
53646     } catch (std::exception& e) {
53647       {
53648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53649       };
53650     } catch (...) {
53651       {
53652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53653       };
53654     }
53655   }
53656 }
53657
53658
53659 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimationSignal() {
53660   void * jresult ;
53661   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
53662
53663   {
53664     try {
53665       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
53666     } catch (std::out_of_range& e) {
53667       {
53668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53669       };
53670     } catch (std::exception& e) {
53671       {
53672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53673       };
53674     } catch (...) {
53675       {
53676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53677       };
53678     }
53679   }
53680   jresult = (void *)result;
53681   return jresult;
53682 }
53683
53684
53685 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimationSignal(void * jarg1) {
53686   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53687
53688   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53689   {
53690     try {
53691       delete arg1;
53692     } catch (std::out_of_range& e) {
53693       {
53694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53695       };
53696     } catch (std::exception& e) {
53697       {
53698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53699       };
53700     } catch (...) {
53701       {
53702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53703       };
53704     }
53705   }
53706 }
53707
53708
53709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Empty(void * jarg1) {
53710   unsigned int jresult ;
53711   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53712   bool result;
53713
53714   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53715   {
53716     try {
53717       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53718     } catch (std::out_of_range& e) {
53719       {
53720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53721       };
53722     } catch (std::exception& e) {
53723       {
53724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53725       };
53726     } catch (...) {
53727       {
53728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53729       };
53730     }
53731   }
53732   jresult = result;
53733   return jresult;
53734 }
53735
53736
53737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ResourceImageSignal_GetConnectionCount(void * jarg1) {
53738   unsigned long jresult ;
53739   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53740   std::size_t result;
53741
53742   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53743   {
53744     try {
53745       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53746     } catch (std::out_of_range& e) {
53747       {
53748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53749       };
53750     } catch (std::exception& e) {
53751       {
53752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53753       };
53754     } catch (...) {
53755       {
53756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53757       };
53758     }
53759   }
53760   jresult = (unsigned long)result;
53761   return jresult;
53762 }
53763
53764
53765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
53766   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53767   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53768
53769   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53770   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53771   {
53772     try {
53773       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
53774     } catch (std::out_of_range& e) {
53775       {
53776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53777       };
53778     } catch (std::exception& e) {
53779       {
53780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53781       };
53782     } catch (...) {
53783       {
53784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53785       };
53786     }
53787   }
53788 }
53789
53790
53791 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
53792   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53793   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53794
53795   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53796   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53797   {
53798     try {
53799       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
53800     } catch (std::out_of_range& e) {
53801       {
53802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53803       };
53804     } catch (std::exception& e) {
53805       {
53806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53807       };
53808     } catch (...) {
53809       {
53810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53811       };
53812     }
53813   }
53814 }
53815
53816
53817 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
53818   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53819   Dali::ResourceImage arg2 ;
53820   Dali::ResourceImage *argp2 ;
53821
53822   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53823   argp2 = (Dali::ResourceImage *)jarg2;
53824   if (!argp2) {
53825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
53826     return ;
53827   }
53828   arg2 = *argp2;
53829   {
53830     try {
53831       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
53832     } catch (std::out_of_range& e) {
53833       {
53834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53835       };
53836     } catch (std::exception& e) {
53837       {
53838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53839       };
53840     } catch (...) {
53841       {
53842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53843       };
53844     }
53845   }
53846 }
53847
53848
53849 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImageSignal() {
53850   void * jresult ;
53851   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
53852
53853   {
53854     try {
53855       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
53856     } catch (std::out_of_range& e) {
53857       {
53858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53859       };
53860     } catch (std::exception& e) {
53861       {
53862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53863       };
53864     } catch (...) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53867       };
53868     }
53869   }
53870   jresult = (void *)result;
53871   return jresult;
53872 }
53873
53874
53875 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ResourceImageSignal(void * jarg1) {
53876   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53877
53878   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53879   {
53880     try {
53881       delete arg1;
53882     } catch (std::out_of_range& e) {
53883       {
53884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53885       };
53886     } catch (std::exception& e) {
53887       {
53888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53889       };
53890     } catch (...) {
53891       {
53892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53893       };
53894     }
53895   }
53896 }
53897
53898
53899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Timer__SWIG_0() {
53900   void * jresult ;
53901   Dali::Timer *result = 0 ;
53902
53903   {
53904     try {
53905       result = (Dali::Timer *)new Dali::Timer();
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53913       };
53914     } catch (...) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53917       };
53918     }
53919   }
53920   jresult = (void *)result;
53921   return jresult;
53922 }
53923
53924
53925 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_New(unsigned int jarg1) {
53926   void * jresult ;
53927   unsigned int arg1 ;
53928   Dali::Timer result;
53929
53930   arg1 = (unsigned int)jarg1;
53931   {
53932     try {
53933       result = Dali::Timer::New(arg1);
53934     } catch (std::out_of_range& e) {
53935       {
53936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53937       };
53938     } catch (std::exception& e) {
53939       {
53940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53945       };
53946     }
53947   }
53948   jresult = new Dali::Timer((const Dali::Timer &)result);
53949   return jresult;
53950 }
53951
53952
53953 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Timer__SWIG_1(void * jarg1) {
53954   void * jresult ;
53955   Dali::Timer *arg1 = 0 ;
53956   Dali::Timer *result = 0 ;
53957
53958   arg1 = (Dali::Timer *)jarg1;
53959   if (!arg1) {
53960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
53961     return 0;
53962   }
53963   {
53964     try {
53965       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
53966     } catch (std::out_of_range& e) {
53967       {
53968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53969       };
53970     } catch (std::exception& e) {
53971       {
53972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53977       };
53978     }
53979   }
53980   jresult = (void *)result;
53981   return jresult;
53982 }
53983
53984
53985 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_Assign(void * jarg1, void * jarg2) {
53986   void * jresult ;
53987   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53988   Dali::Timer *arg2 = 0 ;
53989   Dali::Timer *result = 0 ;
53990
53991   arg1 = (Dali::Timer *)jarg1;
53992   arg2 = (Dali::Timer *)jarg2;
53993   if (!arg2) {
53994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
53995     return 0;
53996   }
53997   {
53998     try {
53999       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54000     } catch (std::out_of_range& e) {
54001       {
54002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54003       };
54004     } catch (std::exception& e) {
54005       {
54006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54007       };
54008     } catch (...) {
54009       {
54010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54011       };
54012     }
54013   }
54014   jresult = (void *)result;
54015   return jresult;
54016 }
54017
54018
54019 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Timer(void * jarg1) {
54020   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54021
54022   arg1 = (Dali::Timer *)jarg1;
54023   {
54024     try {
54025       delete arg1;
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54037       };
54038     }
54039   }
54040 }
54041
54042
54043 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_DownCast(void * jarg1) {
54044   void * jresult ;
54045   Dali::BaseHandle arg1 ;
54046   Dali::BaseHandle *argp1 ;
54047   Dali::Timer result;
54048
54049   argp1 = (Dali::BaseHandle *)jarg1;
54050   if (!argp1) {
54051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54052     return 0;
54053   }
54054   arg1 = *argp1;
54055   {
54056     try {
54057       result = Dali::Timer::DownCast(arg1);
54058     } catch (std::out_of_range& e) {
54059       {
54060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54061       };
54062     } catch (std::exception& e) {
54063       {
54064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54065       };
54066     } catch (...) {
54067       {
54068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54069       };
54070     }
54071   }
54072   jresult = new Dali::Timer((const Dali::Timer &)result);
54073   return jresult;
54074 }
54075
54076
54077 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_Start(void * jarg1) {
54078   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54079
54080   arg1 = (Dali::Timer *)jarg1;
54081   {
54082     try {
54083       (arg1)->Start();
54084     } catch (std::out_of_range& e) {
54085       {
54086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54087       };
54088     } catch (std::exception& e) {
54089       {
54090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54091       };
54092     } catch (...) {
54093       {
54094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54095       };
54096     }
54097   }
54098 }
54099
54100
54101 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_Stop(void * jarg1) {
54102   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54103
54104   arg1 = (Dali::Timer *)jarg1;
54105   {
54106     try {
54107       (arg1)->Stop();
54108     } catch (std::out_of_range& e) {
54109       {
54110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54111       };
54112     } catch (std::exception& e) {
54113       {
54114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54115       };
54116     } catch (...) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54119       };
54120     }
54121   }
54122 }
54123
54124
54125 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54126   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54127   unsigned int arg2 ;
54128
54129   arg1 = (Dali::Timer *)jarg1;
54130   arg2 = (unsigned int)jarg2;
54131   {
54132     try {
54133       (arg1)->SetInterval(arg2);
54134     } catch (std::out_of_range& e) {
54135       {
54136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54137       };
54138     } catch (std::exception& e) {
54139       {
54140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54141       };
54142     } catch (...) {
54143       {
54144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54145       };
54146     }
54147   }
54148 }
54149
54150
54151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Timer_GetInterval(void * jarg1) {
54152   unsigned int jresult ;
54153   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54154   unsigned int result;
54155
54156   arg1 = (Dali::Timer *)jarg1;
54157   {
54158     try {
54159       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54160     } catch (std::out_of_range& e) {
54161       {
54162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54163       };
54164     } catch (std::exception& e) {
54165       {
54166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54171       };
54172     }
54173   }
54174   jresult = result;
54175   return jresult;
54176 }
54177
54178
54179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Timer_IsRunning(void * jarg1) {
54180   unsigned int jresult ;
54181   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54182   bool result;
54183
54184   arg1 = (Dali::Timer *)jarg1;
54185   {
54186     try {
54187       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54188     } catch (std::out_of_range& e) {
54189       {
54190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54191       };
54192     } catch (std::exception& e) {
54193       {
54194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54195       };
54196     } catch (...) {
54197       {
54198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54199       };
54200     }
54201   }
54202   jresult = result;
54203   return jresult;
54204 }
54205
54206
54207 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_TickSignal(void * jarg1) {
54208   void * jresult ;
54209   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54210   Dali::Timer::TimerSignalType *result = 0 ;
54211
54212   arg1 = (Dali::Timer *)jarg1;
54213   {
54214     try {
54215       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54216     } catch (std::out_of_range& e) {
54217       {
54218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54219       };
54220     } catch (std::exception& e) {
54221       {
54222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54223       };
54224     } catch (...) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54227       };
54228     }
54229   }
54230   jresult = (void *)result;
54231   return jresult;
54232 }
54233
54234
54235 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DragAndDropDetector() {
54236   void * jresult ;
54237   Dali::DragAndDropDetector *result = 0 ;
54238
54239   {
54240     try {
54241       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
54242     } catch (std::out_of_range& e) {
54243       {
54244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54245       };
54246     } catch (std::exception& e) {
54247       {
54248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54249       };
54250     } catch (...) {
54251       {
54252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54253       };
54254     }
54255   }
54256   jresult = (void *)result;
54257   return jresult;
54258 }
54259
54260
54261 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DragAndDropDetector(void * jarg1) {
54262   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54263
54264   arg1 = (Dali::DragAndDropDetector *)jarg1;
54265   {
54266     try {
54267       delete arg1;
54268     } catch (std::out_of_range& e) {
54269       {
54270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54271       };
54272     } catch (std::exception& e) {
54273       {
54274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54275       };
54276     } catch (...) {
54277       {
54278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54279       };
54280     }
54281   }
54282 }
54283
54284
54285 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_GetContent(void * jarg1) {
54286   char * jresult ;
54287   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54288   std::string *result = 0 ;
54289
54290   arg1 = (Dali::DragAndDropDetector *)jarg1;
54291   {
54292     try {
54293       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
54294     } catch (std::out_of_range& e) {
54295       {
54296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54297       };
54298     } catch (std::exception& e) {
54299       {
54300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54301       };
54302     } catch (...) {
54303       {
54304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54305       };
54306     }
54307   }
54308   jresult = SWIG_csharp_string_callback(result->c_str());
54309   return jresult;
54310 }
54311
54312
54313 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
54314   void * jresult ;
54315   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54316   Dali::Vector2 result;
54317
54318   arg1 = (Dali::DragAndDropDetector *)jarg1;
54319   {
54320     try {
54321       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54329       };
54330     } catch (...) {
54331       {
54332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54333       };
54334     }
54335   }
54336   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
54337   return jresult;
54338 }
54339
54340
54341 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_EnteredSignal(void * jarg1) {
54342   void * jresult ;
54343   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54344   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54345
54346   arg1 = (Dali::DragAndDropDetector *)jarg1;
54347   {
54348     try {
54349       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54361       };
54362     }
54363   }
54364   jresult = (void *)result;
54365   return jresult;
54366 }
54367
54368
54369 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_ExitedSignal(void * jarg1) {
54370   void * jresult ;
54371   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54372   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54373
54374   arg1 = (Dali::DragAndDropDetector *)jarg1;
54375   {
54376     try {
54377       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
54378     } catch (std::out_of_range& e) {
54379       {
54380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54381       };
54382     } catch (std::exception& e) {
54383       {
54384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54389       };
54390     }
54391   }
54392   jresult = (void *)result;
54393   return jresult;
54394 }
54395
54396
54397 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_MovedSignal(void * jarg1) {
54398   void * jresult ;
54399   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54400   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54401
54402   arg1 = (Dali::DragAndDropDetector *)jarg1;
54403   {
54404     try {
54405       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
54406     } catch (std::out_of_range& e) {
54407       {
54408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54409       };
54410     } catch (std::exception& e) {
54411       {
54412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54413       };
54414     } catch (...) {
54415       {
54416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54417       };
54418     }
54419   }
54420   jresult = (void *)result;
54421   return jresult;
54422 }
54423
54424
54425 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_DroppedSignal(void * jarg1) {
54426   void * jresult ;
54427   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54428   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54429
54430   arg1 = (Dali::DragAndDropDetector *)jarg1;
54431   {
54432     try {
54433       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
54434     } catch (std::out_of_range& e) {
54435       {
54436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54437       };
54438     } catch (std::exception& e) {
54439       {
54440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (...) {
54443       {
54444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54445       };
54446     }
54447   }
54448   jresult = (void *)result;
54449   return jresult;
54450 }
54451
54452
54453 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationExtensions__SWIG_0() {
54454   void * jresult ;
54455   Dali::ApplicationExtensions *result = 0 ;
54456
54457   {
54458     try {
54459       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
54460     } catch (std::out_of_range& e) {
54461       {
54462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54463       };
54464     } catch (std::exception& e) {
54465       {
54466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54467       };
54468     } catch (...) {
54469       {
54470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54471       };
54472     }
54473   }
54474   jresult = (void *)result;
54475   return jresult;
54476 }
54477
54478
54479 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationExtensions__SWIG_1(void * jarg1) {
54480   void * jresult ;
54481   Dali::Application *arg1 = (Dali::Application *) 0 ;
54482   Dali::ApplicationExtensions *result = 0 ;
54483
54484   arg1 = (Dali::Application *)jarg1;
54485   {
54486     try {
54487       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54495       };
54496     } catch (...) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54499       };
54500     }
54501   }
54502   jresult = (void *)result;
54503   return jresult;
54504 }
54505
54506
54507 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationExtensions(void * jarg1) {
54508   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54509
54510   arg1 = (Dali::ApplicationExtensions *)jarg1;
54511   {
54512     try {
54513       delete arg1;
54514     } catch (std::out_of_range& e) {
54515       {
54516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54517       };
54518     } catch (std::exception& e) {
54519       {
54520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54521       };
54522     } catch (...) {
54523       {
54524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54525       };
54526     }
54527   }
54528 }
54529
54530
54531 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Init(void * jarg1) {
54532   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54533
54534   arg1 = (Dali::ApplicationExtensions *)jarg1;
54535   {
54536     try {
54537       (arg1)->Init();
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (...) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54549       };
54550     }
54551   }
54552 }
54553
54554
54555 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Terminate(void * jarg1) {
54556   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54557
54558   arg1 = (Dali::ApplicationExtensions *)jarg1;
54559   {
54560     try {
54561       (arg1)->Terminate();
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54573       };
54574     }
54575   }
54576 }
54577
54578
54579 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Pause(void * jarg1) {
54580   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54581
54582   arg1 = (Dali::ApplicationExtensions *)jarg1;
54583   {
54584     try {
54585       (arg1)->Pause();
54586     } catch (std::out_of_range& e) {
54587       {
54588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54589       };
54590     } catch (std::exception& e) {
54591       {
54592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54593       };
54594     } catch (...) {
54595       {
54596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54597       };
54598     }
54599   }
54600 }
54601
54602
54603 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Resume(void * jarg1) {
54604   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54605
54606   arg1 = (Dali::ApplicationExtensions *)jarg1;
54607   {
54608     try {
54609       (arg1)->Resume();
54610     } catch (std::out_of_range& e) {
54611       {
54612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54613       };
54614     } catch (std::exception& e) {
54615       {
54616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54617       };
54618     } catch (...) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54621       };
54622     }
54623   }
54624 }
54625
54626
54627 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_LanguageChange(void * jarg1) {
54628   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54629
54630   arg1 = (Dali::ApplicationExtensions *)jarg1;
54631   {
54632     try {
54633       (arg1)->LanguageChange();
54634     } catch (std::out_of_range& e) {
54635       {
54636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54637       };
54638     } catch (std::exception& e) {
54639       {
54640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54641       };
54642     } catch (...) {
54643       {
54644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54645       };
54646     }
54647   }
54648 }
54649
54650
54651 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
54652   void * jresult ;
54653   Dali::PositionSize arg1 ;
54654   std::string *arg2 = 0 ;
54655   bool arg3 ;
54656   Dali::PositionSize *argp1 ;
54657   Dali::Window result;
54658
54659   argp1 = (Dali::PositionSize *)jarg1;
54660   if (!argp1) {
54661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54662     return 0;
54663   }
54664   arg1 = *argp1;
54665   if (!jarg2) {
54666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54667     return 0;
54668   }
54669   std::string arg2_str(jarg2);
54670   arg2 = &arg2_str;
54671   arg3 = jarg3 ? true : false;
54672   {
54673     try {
54674       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
54675     } catch (std::out_of_range& e) {
54676       {
54677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54678       };
54679     } catch (std::exception& e) {
54680       {
54681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54682       };
54683     } catch (...) {
54684       {
54685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54686       };
54687     }
54688   }
54689   jresult = new Dali::Window((const Dali::Window &)result);
54690
54691   //argout typemap for const std::string&
54692
54693   return jresult;
54694 }
54695
54696
54697 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_1(void * jarg1, char * jarg2) {
54698   void * jresult ;
54699   Dali::PositionSize arg1 ;
54700   std::string *arg2 = 0 ;
54701   Dali::PositionSize *argp1 ;
54702   Dali::Window result;
54703
54704   argp1 = (Dali::PositionSize *)jarg1;
54705   if (!argp1) {
54706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54707     return 0;
54708   }
54709   arg1 = *argp1;
54710   if (!jarg2) {
54711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54712     return 0;
54713   }
54714   std::string arg2_str(jarg2);
54715   arg2 = &arg2_str;
54716   {
54717     try {
54718       result = Dali::Window::New(arg1,(std::string const &)*arg2);
54719     } catch (std::out_of_range& e) {
54720       {
54721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54722       };
54723     } catch (std::exception& e) {
54724       {
54725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54726       };
54727     } catch (...) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54730       };
54731     }
54732   }
54733   jresult = new Dali::Window((const Dali::Window &)result);
54734
54735   //argout typemap for const std::string&
54736
54737   return jresult;
54738 }
54739
54740
54741 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
54742   void * jresult ;
54743   Dali::PositionSize arg1 ;
54744   std::string *arg2 = 0 ;
54745   std::string *arg3 = 0 ;
54746   bool arg4 ;
54747   Dali::PositionSize *argp1 ;
54748   Dali::Window result;
54749
54750   argp1 = (Dali::PositionSize *)jarg1;
54751   if (!argp1) {
54752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54753     return 0;
54754   }
54755   arg1 = *argp1;
54756   if (!jarg2) {
54757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54758     return 0;
54759   }
54760   std::string arg2_str(jarg2);
54761   arg2 = &arg2_str;
54762   if (!jarg3) {
54763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54764     return 0;
54765   }
54766   std::string arg3_str(jarg3);
54767   arg3 = &arg3_str;
54768   arg4 = jarg4 ? true : false;
54769   {
54770     try {
54771       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
54772     } catch (std::out_of_range& e) {
54773       {
54774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54775       };
54776     } catch (std::exception& e) {
54777       {
54778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54779       };
54780     } catch (...) {
54781       {
54782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54783       };
54784     }
54785   }
54786   jresult = new Dali::Window((const Dali::Window &)result);
54787
54788   //argout typemap for const std::string&
54789
54790
54791   //argout typemap for const std::string&
54792
54793   return jresult;
54794 }
54795
54796
54797 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
54798   void * jresult ;
54799   Dali::PositionSize arg1 ;
54800   std::string *arg2 = 0 ;
54801   std::string *arg3 = 0 ;
54802   Dali::PositionSize *argp1 ;
54803   Dali::Window result;
54804
54805   argp1 = (Dali::PositionSize *)jarg1;
54806   if (!argp1) {
54807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54808     return 0;
54809   }
54810   arg1 = *argp1;
54811   if (!jarg2) {
54812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54813     return 0;
54814   }
54815   std::string arg2_str(jarg2);
54816   arg2 = &arg2_str;
54817   if (!jarg3) {
54818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54819     return 0;
54820   }
54821   std::string arg3_str(jarg3);
54822   arg3 = &arg3_str;
54823   {
54824     try {
54825       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54826     } catch (std::out_of_range& e) {
54827       {
54828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54829       };
54830     } catch (std::exception& e) {
54831       {
54832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54833       };
54834     } catch (...) {
54835       {
54836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54837       };
54838     }
54839   }
54840   jresult = new Dali::Window((const Dali::Window &)result);
54841
54842   //argout typemap for const std::string&
54843
54844
54845   //argout typemap for const std::string&
54846
54847   return jresult;
54848 }
54849
54850
54851 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Window__SWIG_0() {
54852   void * jresult ;
54853   Dali::Window *result = 0 ;
54854
54855   {
54856     try {
54857       result = (Dali::Window *)new Dali::Window();
54858     } catch (std::out_of_range& e) {
54859       {
54860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54861       };
54862     } catch (std::exception& e) {
54863       {
54864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (...) {
54867       {
54868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54869       };
54870     }
54871   }
54872   jresult = (void *)result;
54873   return jresult;
54874 }
54875
54876
54877 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Window(void * jarg1) {
54878   Dali::Window *arg1 = (Dali::Window *) 0 ;
54879
54880   arg1 = (Dali::Window *)jarg1;
54881   {
54882     try {
54883       delete arg1;
54884     } catch (std::out_of_range& e) {
54885       {
54886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54887       };
54888     } catch (std::exception& e) {
54889       {
54890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54891       };
54892     } catch (...) {
54893       {
54894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54895       };
54896     }
54897   }
54898 }
54899
54900
54901 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Window__SWIG_1(void * jarg1) {
54902   void * jresult ;
54903   Dali::Window *arg1 = 0 ;
54904   Dali::Window *result = 0 ;
54905
54906   arg1 = (Dali::Window *)jarg1;
54907   if (!arg1) {
54908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54909     return 0;
54910   }
54911   {
54912     try {
54913       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (...) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54925       };
54926     }
54927   }
54928   jresult = (void *)result;
54929   return jresult;
54930 }
54931
54932
54933 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_Assign(void * jarg1, void * jarg2) {
54934   void * jresult ;
54935   Dali::Window *arg1 = (Dali::Window *) 0 ;
54936   Dali::Window *arg2 = 0 ;
54937   Dali::Window *result = 0 ;
54938
54939   arg1 = (Dali::Window *)jarg1;
54940   arg2 = (Dali::Window *)jarg2;
54941   if (!arg2) {
54942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54943     return 0;
54944   }
54945   {
54946     try {
54947       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
54948     } catch (std::out_of_range& e) {
54949       {
54950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54951       };
54952     } catch (std::exception& e) {
54953       {
54954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54959       };
54960     }
54961   }
54962   jresult = (void *)result;
54963   return jresult;
54964 }
54965
54966
54967 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_ShowIndicator(void * jarg1, int jarg2) {
54968   Dali::Window *arg1 = (Dali::Window *) 0 ;
54969   Dali::Window::IndicatorVisibleMode arg2 ;
54970
54971   arg1 = (Dali::Window *)jarg1;
54972   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
54973   {
54974     try {
54975       (arg1)->ShowIndicator(arg2);
54976     } catch (std::out_of_range& e) {
54977       {
54978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54979       };
54980     } catch (std::exception& e) {
54981       {
54982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54983       };
54984     } catch (...) {
54985       {
54986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54987       };
54988     }
54989   }
54990 }
54991
54992
54993 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
54994   Dali::Window *arg1 = (Dali::Window *) 0 ;
54995   Dali::Window::IndicatorBgOpacity arg2 ;
54996
54997   arg1 = (Dali::Window *)jarg1;
54998   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
54999   {
55000     try {
55001       (arg1)->SetIndicatorBgOpacity(arg2);
55002     } catch (std::out_of_range& e) {
55003       {
55004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55005       };
55006     } catch (std::exception& e) {
55007       {
55008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55009       };
55010     } catch (...) {
55011       {
55012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55013       };
55014     }
55015   }
55016 }
55017
55018
55019 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_RotateIndicator(void * jarg1, int jarg2) {
55020   Dali::Window *arg1 = (Dali::Window *) 0 ;
55021   Dali::Window::WindowOrientation arg2 ;
55022
55023   arg1 = (Dali::Window *)jarg1;
55024   arg2 = (Dali::Window::WindowOrientation)jarg2;
55025   {
55026     try {
55027       (arg1)->RotateIndicator(arg2);
55028     } catch (std::out_of_range& e) {
55029       {
55030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55031       };
55032     } catch (std::exception& e) {
55033       {
55034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55035       };
55036     } catch (...) {
55037       {
55038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55039       };
55040     }
55041   }
55042 }
55043
55044
55045 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
55046   Dali::Window *arg1 = (Dali::Window *) 0 ;
55047   std::string arg2 ;
55048   std::string arg3 ;
55049
55050   arg1 = (Dali::Window *)jarg1;
55051   if (!jarg2) {
55052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55053     return ;
55054   }
55055   (&arg2)->assign(jarg2);
55056   if (!jarg3) {
55057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55058     return ;
55059   }
55060   (&arg3)->assign(jarg3);
55061   {
55062     try {
55063       (arg1)->SetClass(arg2,arg3);
55064     } catch (std::out_of_range& e) {
55065       {
55066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55067       };
55068     } catch (std::exception& e) {
55069       {
55070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55071       };
55072     } catch (...) {
55073       {
55074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55075       };
55076     }
55077   }
55078 }
55079
55080
55081 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Raise(void * jarg1) {
55082   Dali::Window *arg1 = (Dali::Window *) 0 ;
55083
55084   arg1 = (Dali::Window *)jarg1;
55085   {
55086     try {
55087       (arg1)->Raise();
55088     } catch (std::out_of_range& e) {
55089       {
55090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55091       };
55092     } catch (std::exception& e) {
55093       {
55094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55095       };
55096     } catch (...) {
55097       {
55098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55099       };
55100     }
55101   }
55102 }
55103
55104
55105 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Lower(void * jarg1) {
55106   Dali::Window *arg1 = (Dali::Window *) 0 ;
55107
55108   arg1 = (Dali::Window *)jarg1;
55109   {
55110     try {
55111       (arg1)->Lower();
55112     } catch (std::out_of_range& e) {
55113       {
55114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55115       };
55116     } catch (std::exception& e) {
55117       {
55118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55119       };
55120     } catch (...) {
55121       {
55122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55123       };
55124     }
55125   }
55126 }
55127
55128
55129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Activate(void * jarg1) {
55130   Dali::Window *arg1 = (Dali::Window *) 0 ;
55131
55132   arg1 = (Dali::Window *)jarg1;
55133   {
55134     try {
55135       (arg1)->Activate();
55136     } catch (std::out_of_range& e) {
55137       {
55138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55139       };
55140     } catch (std::exception& e) {
55141       {
55142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55147       };
55148     }
55149   }
55150 }
55151
55152
55153 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
55154   Dali::Window *arg1 = (Dali::Window *) 0 ;
55155   Dali::Window::WindowOrientation arg2 ;
55156
55157   arg1 = (Dali::Window *)jarg1;
55158   arg2 = (Dali::Window::WindowOrientation)jarg2;
55159   {
55160     try {
55161       (arg1)->AddAvailableOrientation(arg2);
55162     } catch (std::out_of_range& e) {
55163       {
55164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55165       };
55166     } catch (std::exception& e) {
55167       {
55168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55169       };
55170     } catch (...) {
55171       {
55172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55173       };
55174     }
55175   }
55176 }
55177
55178
55179 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
55180   Dali::Window *arg1 = (Dali::Window *) 0 ;
55181   Dali::Window::WindowOrientation arg2 ;
55182
55183   arg1 = (Dali::Window *)jarg1;
55184   arg2 = (Dali::Window::WindowOrientation)jarg2;
55185   {
55186     try {
55187       (arg1)->RemoveAvailableOrientation(arg2);
55188     } catch (std::out_of_range& e) {
55189       {
55190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55191       };
55192     } catch (std::exception& e) {
55193       {
55194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55199       };
55200     }
55201   }
55202 }
55203
55204
55205 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
55206   Dali::Window *arg1 = (Dali::Window *) 0 ;
55207   Dali::Window::WindowOrientation arg2 ;
55208
55209   arg1 = (Dali::Window *)jarg1;
55210   arg2 = (Dali::Window::WindowOrientation)jarg2;
55211   {
55212     try {
55213       (arg1)->SetPreferredOrientation(arg2);
55214     } catch (std::out_of_range& e) {
55215       {
55216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55217       };
55218     } catch (std::exception& e) {
55219       {
55220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55221       };
55222     } catch (...) {
55223       {
55224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55225       };
55226     }
55227   }
55228 }
55229
55230
55231 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Window_GetPreferredOrientation(void * jarg1) {
55232   int jresult ;
55233   Dali::Window *arg1 = (Dali::Window *) 0 ;
55234   Dali::Window::WindowOrientation result;
55235
55236   arg1 = (Dali::Window *)jarg1;
55237   {
55238     try {
55239       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
55240     } catch (std::out_of_range& e) {
55241       {
55242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55243       };
55244     } catch (std::exception& e) {
55245       {
55246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55247       };
55248     } catch (...) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55251       };
55252     }
55253   }
55254   jresult = (int)result;
55255   return jresult;
55256 }
55257
55258
55259 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_GetDragAndDropDetector(void * jarg1) {
55260   void * jresult ;
55261   Dali::Window *arg1 = (Dali::Window *) 0 ;
55262   Dali::DragAndDropDetector result;
55263
55264   arg1 = (Dali::Window *)jarg1;
55265   {
55266     try {
55267       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
55268     } catch (std::out_of_range& e) {
55269       {
55270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55271       };
55272     } catch (std::exception& e) {
55273       {
55274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55275       };
55276     } catch (...) {
55277       {
55278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55279       };
55280     }
55281   }
55282   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
55283   return jresult;
55284 }
55285
55286
55287 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_GetNativeHandle(void * jarg1) {
55288   void * jresult ;
55289   Dali::Window *arg1 = (Dali::Window *) 0 ;
55290   Dali::Any result;
55291
55292   arg1 = (Dali::Window *)jarg1;
55293   {
55294     try {
55295       result = ((Dali::Window const *)arg1)->GetNativeHandle();
55296     } catch (std::out_of_range& e) {
55297       {
55298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55299       };
55300     } catch (std::exception& e) {
55301       {
55302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (...) {
55305       {
55306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55307       };
55308     }
55309   }
55310   jresult = new Dali::Any((const Dali::Any &)result);
55311   return jresult;
55312 }
55313
55314
55315 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
55316   void * jresult ;
55317   Dali::Window *arg1 = (Dali::Window *) 0 ;
55318   Dali::Window::IndicatorSignalType *result = 0 ;
55319
55320   arg1 = (Dali::Window *)jarg1;
55321   {
55322     try {
55323       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
55324     } catch (std::out_of_range& e) {
55325       {
55326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55327       };
55328     } catch (std::exception& e) {
55329       {
55330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55331       };
55332     } catch (...) {
55333       {
55334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55335       };
55336     }
55337   }
55338   jresult = (void *)result;
55339   return jresult;
55340 }
55341
55342
55343 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_0() {
55344   void * jresult ;
55345   Dali::Application result;
55346
55347   {
55348     try {
55349       result = Dali::Application::New();
55350     } catch (std::out_of_range& e) {
55351       {
55352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55353       };
55354     } catch (std::exception& e) {
55355       {
55356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55357       };
55358     } catch (...) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55361       };
55362     }
55363   }
55364   jresult = new Dali::Application((const Dali::Application &)result);
55365   return jresult;
55366 }
55367
55368
55369 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_1(int jarg1) {
55370   void * jresult ;
55371   int *arg1 = (int *) 0 ;
55372   char ***arg2 ;
55373   Dali::Application result;
55374
55375   {
55376     // Todo generate argv data from the C# args
55377     char **array;         // two dimensional array
55378     int numStrings = 1;     // number of strings
55379     int stringLength = 30;      // max string length.
55380     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55381     argV = array;
55382
55383     // allocate the string data
55384     for( int i=0; i < numStrings; i++)
55385     {
55386       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55387     }
55388     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55389
55390     strcpy( array[0], "dali-csharp-app");
55391
55392     arg1 = &argC;
55393     arg2 = &argV;
55394   }
55395   {
55396     try {
55397       result = Dali::Application::New(arg1,arg2);
55398     } catch (std::out_of_range& e) {
55399       {
55400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55401       };
55402     } catch (std::exception& e) {
55403       {
55404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55405       };
55406     } catch (...) {
55407       {
55408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55409       };
55410     }
55411   }
55412   jresult = new Dali::Application((const Dali::Application &)result);
55413   return jresult;
55414 }
55415
55416
55417 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_2(int jarg1, char * jarg3) {
55418   void * jresult ;
55419   int *arg1 = (int *) 0 ;
55420   char ***arg2 ;
55421   std::string *arg3 = 0 ;
55422   Dali::Application result;
55423
55424   {
55425     // Todo generate argv data from the C# args
55426     char **array;         // two dimensional array
55427     int numStrings = 1;     // number of strings
55428     int stringLength = 30;      // max string length.
55429     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55430     argV = array;
55431
55432     // allocate the string data
55433     for( int i=0; i < numStrings; i++)
55434     {
55435       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55436     }
55437     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55438
55439     strcpy( array[0], "dali-csharp-app");
55440
55441     arg1 = &argC;
55442     arg2 = &argV;
55443   }
55444   if (!jarg3) {
55445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55446     return 0;
55447   }
55448   std::string arg3_str(jarg3);
55449   arg3 = &arg3_str;
55450   {
55451     try {
55452       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55453     } catch (std::out_of_range& e) {
55454       {
55455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55456       };
55457     } catch (std::exception& e) {
55458       {
55459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55460       };
55461     } catch (...) {
55462       {
55463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55464       };
55465     }
55466   }
55467   jresult = new Dali::Application((const Dali::Application &)result);
55468
55469   //argout typemap for const std::string&
55470
55471   return jresult;
55472 }
55473
55474
55475 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55476   void * jresult ;
55477   int *arg1 = (int *) 0 ;
55478   char ***arg2 ;
55479   std::string *arg3 = 0 ;
55480   Dali::Application::WINDOW_MODE arg4 ;
55481   Dali::Application result;
55482
55483   {
55484     // Todo generate argv data from the C# args
55485     char **array;         // two dimensional array
55486     int numStrings = 1;     // number of strings
55487     int stringLength = 30;      // max string length.
55488     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55489     argV = array;
55490
55491     // allocate the string data
55492     for( int i=0; i < numStrings; i++)
55493     {
55494       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55495     }
55496     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55497
55498     strcpy( array[0], "dali-csharp-app");
55499
55500     arg1 = &argC;
55501     arg2 = &argV;
55502   }
55503   if (!jarg3) {
55504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55505     return 0;
55506   }
55507   std::string arg3_str(jarg3);
55508   arg3 = &arg3_str;
55509   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55510   {
55511     try {
55512       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55513     } catch (std::out_of_range& e) {
55514       {
55515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55516       };
55517     } catch (std::exception& e) {
55518       {
55519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55524       };
55525     }
55526   }
55527   jresult = new Dali::Application((const Dali::Application &)result);
55528
55529   //argout typemap for const std::string&
55530
55531   return jresult;
55532 }
55533
55534
55535 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Application__SWIG_0() {
55536   void * jresult ;
55537   Dali::Application *result = 0 ;
55538
55539   {
55540     try {
55541       result = (Dali::Application *)new Dali::Application();
55542     } catch (std::out_of_range& e) {
55543       {
55544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (std::exception& e) {
55547       {
55548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55549       };
55550     } catch (...) {
55551       {
55552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55553       };
55554     }
55555   }
55556   jresult = (void *)result;
55557   return jresult;
55558 }
55559
55560
55561 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Application__SWIG_1(void * jarg1) {
55562   void * jresult ;
55563   Dali::Application *arg1 = 0 ;
55564   Dali::Application *result = 0 ;
55565
55566   arg1 = (Dali::Application *)jarg1;
55567   if (!arg1) {
55568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55569     return 0;
55570   }
55571   {
55572     try {
55573       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55574     } catch (std::out_of_range& e) {
55575       {
55576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55577       };
55578     } catch (std::exception& e) {
55579       {
55580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55581       };
55582     } catch (...) {
55583       {
55584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55585       };
55586     }
55587   }
55588   jresult = (void *)result;
55589   return jresult;
55590 }
55591
55592
55593 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_Assign(void * jarg1, void * jarg2) {
55594   void * jresult ;
55595   Dali::Application *arg1 = (Dali::Application *) 0 ;
55596   Dali::Application *arg2 = 0 ;
55597   Dali::Application *result = 0 ;
55598
55599   arg1 = (Dali::Application *)jarg1;
55600   arg2 = (Dali::Application *)jarg2;
55601   if (!arg2) {
55602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55603     return 0;
55604   }
55605   {
55606     try {
55607       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55608     } catch (std::out_of_range& e) {
55609       {
55610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55611       };
55612     } catch (std::exception& e) {
55613       {
55614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55615       };
55616     } catch (...) {
55617       {
55618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55619       };
55620     }
55621   }
55622   jresult = (void *)result;
55623   return jresult;
55624 }
55625
55626
55627 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Application(void * jarg1) {
55628   Dali::Application *arg1 = (Dali::Application *) 0 ;
55629
55630   arg1 = (Dali::Application *)jarg1;
55631   {
55632     try {
55633       delete arg1;
55634     } catch (std::out_of_range& e) {
55635       {
55636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (std::exception& e) {
55639       {
55640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55641       };
55642     } catch (...) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55645       };
55646     }
55647   }
55648 }
55649
55650
55651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_MainLoop__SWIG_0(void * jarg1) {
55652   Dali::Application *arg1 = (Dali::Application *) 0 ;
55653
55654   arg1 = (Dali::Application *)jarg1;
55655   {
55656     try {
55657       (arg1)->MainLoop();
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (...) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55669       };
55670     }
55671   }
55672 }
55673
55674
55675 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55676   Dali::Application *arg1 = (Dali::Application *) 0 ;
55677   Configuration::ContextLoss arg2 ;
55678   Configuration::ContextLoss *argp2 ;
55679
55680   arg1 = (Dali::Application *)jarg1;
55681   argp2 = (Configuration::ContextLoss *)jarg2;
55682   if (!argp2) {
55683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55684     return ;
55685   }
55686   arg2 = *argp2;
55687   {
55688     try {
55689       (arg1)->MainLoop(arg2);
55690     } catch (std::out_of_range& e) {
55691       {
55692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55693       };
55694     } catch (std::exception& e) {
55695       {
55696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55697       };
55698     } catch (...) {
55699       {
55700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55701       };
55702     }
55703   }
55704 }
55705
55706
55707 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_Lower(void * jarg1) {
55708   Dali::Application *arg1 = (Dali::Application *) 0 ;
55709
55710   arg1 = (Dali::Application *)jarg1;
55711   {
55712     try {
55713       (arg1)->Lower();
55714     } catch (std::out_of_range& e) {
55715       {
55716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55717       };
55718     } catch (std::exception& e) {
55719       {
55720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55721       };
55722     } catch (...) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55725       };
55726     }
55727   }
55728 }
55729
55730
55731 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_Quit(void * jarg1) {
55732   Dali::Application *arg1 = (Dali::Application *) 0 ;
55733
55734   arg1 = (Dali::Application *)jarg1;
55735   {
55736     try {
55737       (arg1)->Quit();
55738     } catch (std::out_of_range& e) {
55739       {
55740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55741       };
55742     } catch (std::exception& e) {
55743       {
55744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55745       };
55746     } catch (...) {
55747       {
55748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55749       };
55750     }
55751   }
55752 }
55753
55754
55755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Application_AddIdle(void * jarg1, void * jarg2) {
55756   unsigned int jresult ;
55757   Dali::Application *arg1 = (Dali::Application *) 0 ;
55758   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55759   bool result;
55760
55761   arg1 = (Dali::Application *)jarg1;
55762   arg2 = (Dali::CallbackBase *)jarg2;
55763   {
55764     try {
55765       result = (bool)(arg1)->AddIdle(arg2);
55766     } catch (std::out_of_range& e) {
55767       {
55768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55769       };
55770     } catch (std::exception& e) {
55771       {
55772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (...) {
55775       {
55776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55777       };
55778     }
55779   }
55780   jresult = result;
55781   return jresult;
55782 }
55783
55784
55785 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_GetWindow(void * jarg1) {
55786   void * jresult ;
55787   Dali::Application *arg1 = (Dali::Application *) 0 ;
55788   Dali::Window result;
55789
55790   arg1 = (Dali::Application *)jarg1;
55791   {
55792     try {
55793       result = (arg1)->GetWindow();
55794     } catch (std::out_of_range& e) {
55795       {
55796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55797       };
55798     } catch (std::exception& e) {
55799       {
55800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55801       };
55802     } catch (...) {
55803       {
55804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55805       };
55806     }
55807   }
55808   jresult = new Dali::Window((const Dali::Window &)result);
55809   return jresult;
55810 }
55811
55812
55813 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55814   Dali::Application *arg1 = (Dali::Application *) 0 ;
55815   Dali::PositionSize arg2 ;
55816   std::string *arg3 = 0 ;
55817   Dali::PositionSize *argp2 ;
55818
55819   arg1 = (Dali::Application *)jarg1;
55820   argp2 = (Dali::PositionSize *)jarg2;
55821   if (!argp2) {
55822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55823     return ;
55824   }
55825   arg2 = *argp2;
55826   if (!jarg3) {
55827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55828     return ;
55829   }
55830   std::string arg3_str(jarg3);
55831   arg3 = &arg3_str;
55832   {
55833     try {
55834       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55835     } catch (std::out_of_range& e) {
55836       {
55837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55838       };
55839     } catch (std::exception& e) {
55840       {
55841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55842       };
55843     } catch (...) {
55844       {
55845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55846       };
55847     }
55848   }
55849
55850   //argout typemap for const std::string&
55851
55852 }
55853
55854
55855 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Application_GetResourcePath() {
55856   char * jresult ;
55857   std::string result;
55858
55859   {
55860     try {
55861       result = Dali::Application::GetResourcePath();
55862     } catch (std::out_of_range& e) {
55863       {
55864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55865       };
55866     } catch (std::exception& e) {
55867       {
55868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55869       };
55870     } catch (...) {
55871       {
55872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55873       };
55874     }
55875   }
55876   jresult = SWIG_csharp_string_callback((&result)->c_str());
55877   return jresult;
55878 }
55879
55880
55881 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_SetViewMode(void * jarg1, int jarg2) {
55882   Dali::Application *arg1 = (Dali::Application *) 0 ;
55883   Dali::ViewMode arg2 ;
55884
55885   arg1 = (Dali::Application *)jarg1;
55886   arg2 = (Dali::ViewMode)jarg2;
55887   {
55888     try {
55889       (arg1)->SetViewMode(arg2);
55890     } catch (std::out_of_range& e) {
55891       {
55892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55893       };
55894     } catch (std::exception& e) {
55895       {
55896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55897       };
55898     } catch (...) {
55899       {
55900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55901       };
55902     }
55903   }
55904 }
55905
55906
55907 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Application_GetViewMode(void * jarg1) {
55908   int jresult ;
55909   Dali::Application *arg1 = (Dali::Application *) 0 ;
55910   Dali::ViewMode result;
55911
55912   arg1 = (Dali::Application *)jarg1;
55913   {
55914     try {
55915       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55916     } catch (std::out_of_range& e) {
55917       {
55918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55919       };
55920     } catch (std::exception& e) {
55921       {
55922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55923       };
55924     } catch (...) {
55925       {
55926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55927       };
55928     }
55929   }
55930   jresult = (int)result;
55931   return jresult;
55932 }
55933
55934
55935 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_SetStereoBase(void * jarg1, float jarg2) {
55936   Dali::Application *arg1 = (Dali::Application *) 0 ;
55937   float arg2 ;
55938
55939   arg1 = (Dali::Application *)jarg1;
55940   arg2 = (float)jarg2;
55941   {
55942     try {
55943       (arg1)->SetStereoBase(arg2);
55944     } catch (std::out_of_range& e) {
55945       {
55946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55947       };
55948     } catch (std::exception& e) {
55949       {
55950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55951       };
55952     } catch (...) {
55953       {
55954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55955       };
55956     }
55957   }
55958 }
55959
55960
55961 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Application_GetStereoBase(void * jarg1) {
55962   float jresult ;
55963   Dali::Application *arg1 = (Dali::Application *) 0 ;
55964   float result;
55965
55966   arg1 = (Dali::Application *)jarg1;
55967   {
55968     try {
55969       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55970     } catch (std::out_of_range& e) {
55971       {
55972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55973       };
55974     } catch (std::exception& e) {
55975       {
55976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55977       };
55978     } catch (...) {
55979       {
55980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55981       };
55982     }
55983   }
55984   jresult = result;
55985   return jresult;
55986 }
55987
55988
55989 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_InitSignal(void * jarg1) {
55990   void * jresult ;
55991   Dali::Application *arg1 = (Dali::Application *) 0 ;
55992   Dali::Application::AppSignalType *result = 0 ;
55993
55994   arg1 = (Dali::Application *)jarg1;
55995   {
55996     try {
55997       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55998     } catch (std::out_of_range& e) {
55999       {
56000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56001       };
56002     } catch (std::exception& e) {
56003       {
56004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56005       };
56006     } catch (...) {
56007       {
56008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56009       };
56010     }
56011   }
56012   jresult = (void *)result;
56013   return jresult;
56014 }
56015
56016
56017 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_TerminateSignal(void * jarg1) {
56018   void * jresult ;
56019   Dali::Application *arg1 = (Dali::Application *) 0 ;
56020   Dali::Application::AppSignalType *result = 0 ;
56021
56022   arg1 = (Dali::Application *)jarg1;
56023   {
56024     try {
56025       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
56026     } catch (std::out_of_range& e) {
56027       {
56028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (std::exception& e) {
56031       {
56032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56033       };
56034     } catch (...) {
56035       {
56036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56037       };
56038     }
56039   }
56040   jresult = (void *)result;
56041   return jresult;
56042 }
56043
56044
56045 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_PauseSignal(void * jarg1) {
56046   void * jresult ;
56047   Dali::Application *arg1 = (Dali::Application *) 0 ;
56048   Dali::Application::AppSignalType *result = 0 ;
56049
56050   arg1 = (Dali::Application *)jarg1;
56051   {
56052     try {
56053       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
56054     } catch (std::out_of_range& e) {
56055       {
56056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56057       };
56058     } catch (std::exception& e) {
56059       {
56060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56061       };
56062     } catch (...) {
56063       {
56064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56065       };
56066     }
56067   }
56068   jresult = (void *)result;
56069   return jresult;
56070 }
56071
56072
56073 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResumeSignal(void * jarg1) {
56074   void * jresult ;
56075   Dali::Application *arg1 = (Dali::Application *) 0 ;
56076   Dali::Application::AppSignalType *result = 0 ;
56077
56078   arg1 = (Dali::Application *)jarg1;
56079   {
56080     try {
56081       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
56082     } catch (std::out_of_range& e) {
56083       {
56084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56085       };
56086     } catch (std::exception& e) {
56087       {
56088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56089       };
56090     } catch (...) {
56091       {
56092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56093       };
56094     }
56095   }
56096   jresult = (void *)result;
56097   return jresult;
56098 }
56099
56100
56101 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResetSignal(void * jarg1) {
56102   void * jresult ;
56103   Dali::Application *arg1 = (Dali::Application *) 0 ;
56104   Dali::Application::AppSignalType *result = 0 ;
56105
56106   arg1 = (Dali::Application *)jarg1;
56107   {
56108     try {
56109       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56121       };
56122     }
56123   }
56124   jresult = (void *)result;
56125   return jresult;
56126 }
56127
56128
56129 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResizeSignal(void * jarg1) {
56130   void * jresult ;
56131   Dali::Application *arg1 = (Dali::Application *) 0 ;
56132   Dali::Application::AppSignalType *result = 0 ;
56133
56134   arg1 = (Dali::Application *)jarg1;
56135   {
56136     try {
56137       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
56138     } catch (std::out_of_range& e) {
56139       {
56140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56141       };
56142     } catch (std::exception& e) {
56143       {
56144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56149       };
56150     }
56151   }
56152   jresult = (void *)result;
56153   return jresult;
56154 }
56155
56156
56157 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_AppControlSignal(void * jarg1) {
56158   void * jresult ;
56159   Dali::Application *arg1 = (Dali::Application *) 0 ;
56160   Dali::Application::AppControlSignalType *result = 0 ;
56161
56162   arg1 = (Dali::Application *)jarg1;
56163   {
56164     try {
56165       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
56166     } catch (std::out_of_range& e) {
56167       {
56168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56169       };
56170     } catch (std::exception& e) {
56171       {
56172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56173       };
56174     } catch (...) {
56175       {
56176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56177       };
56178     }
56179   }
56180   jresult = (void *)result;
56181   return jresult;
56182 }
56183
56184
56185 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_LanguageChangedSignal(void * jarg1) {
56186   void * jresult ;
56187   Dali::Application *arg1 = (Dali::Application *) 0 ;
56188   Dali::Application::AppSignalType *result = 0 ;
56189
56190   arg1 = (Dali::Application *)jarg1;
56191   {
56192     try {
56193       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56194     } catch (std::out_of_range& e) {
56195       {
56196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56197       };
56198     } catch (std::exception& e) {
56199       {
56200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56201       };
56202     } catch (...) {
56203       {
56204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56205       };
56206     }
56207   }
56208   jresult = (void *)result;
56209   return jresult;
56210 }
56211
56212
56213 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_RegionChangedSignal(void * jarg1) {
56214   void * jresult ;
56215   Dali::Application *arg1 = (Dali::Application *) 0 ;
56216   Dali::Application::AppSignalType *result = 0 ;
56217
56218   arg1 = (Dali::Application *)jarg1;
56219   {
56220     try {
56221       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56222     } catch (std::out_of_range& e) {
56223       {
56224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56225       };
56226     } catch (std::exception& e) {
56227       {
56228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56229       };
56230     } catch (...) {
56231       {
56232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56233       };
56234     }
56235   }
56236   jresult = (void *)result;
56237   return jresult;
56238 }
56239
56240
56241 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_BatteryLowSignal(void * jarg1) {
56242   void * jresult ;
56243   Dali::Application *arg1 = (Dali::Application *) 0 ;
56244   Dali::Application::AppSignalType *result = 0 ;
56245
56246   arg1 = (Dali::Application *)jarg1;
56247   {
56248     try {
56249       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56250     } catch (std::out_of_range& e) {
56251       {
56252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56253       };
56254     } catch (std::exception& e) {
56255       {
56256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56257       };
56258     } catch (...) {
56259       {
56260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56261       };
56262     }
56263   }
56264   jresult = (void *)result;
56265   return jresult;
56266 }
56267
56268
56269 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_MemoryLowSignal(void * jarg1) {
56270   void * jresult ;
56271   Dali::Application *arg1 = (Dali::Application *) 0 ;
56272   Dali::Application::AppSignalType *result = 0 ;
56273
56274   arg1 = (Dali::Application *)jarg1;
56275   {
56276     try {
56277       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56278     } catch (std::out_of_range& e) {
56279       {
56280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56281       };
56282     } catch (std::exception& e) {
56283       {
56284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56285       };
56286     } catch (...) {
56287       {
56288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56289       };
56290     }
56291   }
56292   jresult = (void *)result;
56293   return jresult;
56294 }
56295
56296
56297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ApplicationSignal_Empty(void * jarg1) {
56298   unsigned int jresult ;
56299   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56300   bool result;
56301
56302   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56303   {
56304     try {
56305       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56306     } catch (std::out_of_range& e) {
56307       {
56308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56309       };
56310     } catch (std::exception& e) {
56311       {
56312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56313       };
56314     } catch (...) {
56315       {
56316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56317       };
56318     }
56319   }
56320   jresult = result;
56321   return jresult;
56322 }
56323
56324
56325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ApplicationSignal_GetConnectionCount(void * jarg1) {
56326   unsigned long jresult ;
56327   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56328   std::size_t result;
56329
56330   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56331   {
56332     try {
56333       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56334     } catch (std::out_of_range& e) {
56335       {
56336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56337       };
56338     } catch (std::exception& e) {
56339       {
56340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56341       };
56342     } catch (...) {
56343       {
56344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56345       };
56346     }
56347   }
56348   jresult = (unsigned long)result;
56349   return jresult;
56350 }
56351
56352
56353 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56354   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56355   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56356
56357   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56358   arg2 = (void (*)(Dali::Application &))jarg2;
56359   {
56360     try {
56361       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56369       };
56370     } catch (...) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56373       };
56374     }
56375   }
56376 }
56377
56378
56379 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56380   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56381   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56382
56383   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56384   arg2 = (void (*)(Dali::Application &))jarg2;
56385   {
56386     try {
56387       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56388     } catch (std::out_of_range& e) {
56389       {
56390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56391       };
56392     } catch (std::exception& e) {
56393       {
56394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56395       };
56396     } catch (...) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56399       };
56400     }
56401   }
56402 }
56403
56404
56405 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56406   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56407   Dali::Application *arg2 = 0 ;
56408
56409   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56410   arg2 = (Dali::Application *)jarg2;
56411   if (!arg2) {
56412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56413     return ;
56414   }
56415   {
56416     try {
56417       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56418     } catch (std::out_of_range& e) {
56419       {
56420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56421       };
56422     } catch (std::exception& e) {
56423       {
56424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56425       };
56426     } catch (...) {
56427       {
56428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56429       };
56430     }
56431   }
56432 }
56433
56434
56435 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationSignal() {
56436   void * jresult ;
56437   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56438
56439   {
56440     try {
56441       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56442     } catch (std::out_of_range& e) {
56443       {
56444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56445       };
56446     } catch (std::exception& e) {
56447       {
56448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56449       };
56450     } catch (...) {
56451       {
56452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56453       };
56454     }
56455   }
56456   jresult = (void *)result;
56457   return jresult;
56458 }
56459
56460
56461 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationSignal(void * jarg1) {
56462   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56463
56464   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56465   {
56466     try {
56467       delete arg1;
56468     } catch (std::out_of_range& e) {
56469       {
56470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56471       };
56472     } catch (std::exception& e) {
56473       {
56474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56475       };
56476     } catch (...) {
56477       {
56478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56479       };
56480     }
56481   }
56482 }
56483
56484
56485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Empty(void * jarg1) {
56486   unsigned int jresult ;
56487   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56488   bool result;
56489
56490   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56491   {
56492     try {
56493       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56501       };
56502     } catch (...) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56505       };
56506     }
56507   }
56508   jresult = result;
56509   return jresult;
56510 }
56511
56512
56513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56514   unsigned long jresult ;
56515   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56516   std::size_t result;
56517
56518   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56519   {
56520     try {
56521       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56522     } catch (std::out_of_range& e) {
56523       {
56524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56525       };
56526     } catch (std::exception& e) {
56527       {
56528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56529       };
56530     } catch (...) {
56531       {
56532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56533       };
56534     }
56535   }
56536   jresult = (unsigned long)result;
56537   return jresult;
56538 }
56539
56540
56541 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56542   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56543   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56544
56545   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56546   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56547   {
56548     try {
56549       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56550     } catch (std::out_of_range& e) {
56551       {
56552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56553       };
56554     } catch (std::exception& e) {
56555       {
56556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56557       };
56558     } catch (...) {
56559       {
56560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56561       };
56562     }
56563   }
56564 }
56565
56566
56567 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56568   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56569   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56570
56571   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56572   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56573   {
56574     try {
56575       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56576     } catch (std::out_of_range& e) {
56577       {
56578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56579       };
56580     } catch (std::exception& e) {
56581       {
56582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56583       };
56584     } catch (...) {
56585       {
56586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56587       };
56588     }
56589   }
56590 }
56591
56592
56593 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56594   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56595   Dali::Application *arg2 = 0 ;
56596   void *arg3 = (void *) 0 ;
56597
56598   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56599   arg2 = (Dali::Application *)jarg2;
56600   if (!arg2) {
56601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56602     return ;
56603   }
56604   arg3 = jarg3;
56605   {
56606     try {
56607       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56608     } catch (std::out_of_range& e) {
56609       {
56610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56611       };
56612     } catch (std::exception& e) {
56613       {
56614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56615       };
56616     } catch (...) {
56617       {
56618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56619       };
56620     }
56621   }
56622 }
56623
56624
56625 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationControlSignal() {
56626   void * jresult ;
56627   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56628
56629   {
56630     try {
56631       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56632     } catch (std::out_of_range& e) {
56633       {
56634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56635       };
56636     } catch (std::exception& e) {
56637       {
56638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56639       };
56640     } catch (...) {
56641       {
56642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56643       };
56644     }
56645   }
56646   jresult = (void *)result;
56647   return jresult;
56648 }
56649
56650
56651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationControlSignal(void * jarg1) {
56652   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56653
56654   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56655   {
56656     try {
56657       delete arg1;
56658     } catch (std::out_of_range& e) {
56659       {
56660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56661       };
56662     } catch (std::exception& e) {
56663       {
56664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56665       };
56666     } catch (...) {
56667       {
56668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56669       };
56670     }
56671   }
56672 }
56673
56674
56675 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimerSignalType() {
56676   void * jresult ;
56677   Dali::Signal< bool () > *result = 0 ;
56678
56679   {
56680     try {
56681       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56682     } catch (std::out_of_range& e) {
56683       {
56684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56685       };
56686     } catch (std::exception& e) {
56687       {
56688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56689       };
56690     } catch (...) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56693       };
56694     }
56695   }
56696   jresult = (void *)result;
56697   return jresult;
56698 }
56699
56700
56701 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TimerSignalType(void * jarg1) {
56702   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56703
56704   arg1 = (Dali::Signal< bool () > *)jarg1;
56705   {
56706     try {
56707       delete arg1;
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56715       };
56716     } catch (...) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56719       };
56720     }
56721   }
56722 }
56723
56724
56725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TimerSignalType_Empty(void * jarg1) {
56726   unsigned int jresult ;
56727   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56728   bool result;
56729
56730   arg1 = (Dali::Signal< bool () > *)jarg1;
56731   {
56732     try {
56733       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
56734     } catch (std::out_of_range& e) {
56735       {
56736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56737       };
56738     } catch (std::exception& e) {
56739       {
56740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56741       };
56742     } catch (...) {
56743       {
56744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56745       };
56746     }
56747   }
56748   jresult = result;
56749   return jresult;
56750 }
56751
56752
56753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TimerSignalType_GetConnectionCount(void * jarg1) {
56754   unsigned long jresult ;
56755   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56756   std::size_t result;
56757
56758   arg1 = (Dali::Signal< bool () > *)jarg1;
56759   {
56760     try {
56761       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
56762     } catch (std::out_of_range& e) {
56763       {
56764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56765       };
56766     } catch (std::exception& e) {
56767       {
56768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56769       };
56770     } catch (...) {
56771       {
56772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56773       };
56774     }
56775   }
56776   jresult = (unsigned long)result;
56777   return jresult;
56778 }
56779
56780
56781 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
56782   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56783   bool (*arg2)() = (bool (*)()) 0 ;
56784
56785   arg1 = (Dali::Signal< bool () > *)jarg1;
56786   arg2 = (bool (*)())jarg2;
56787   {
56788     try {
56789       (arg1)->Connect(arg2);
56790     } catch (std::out_of_range& e) {
56791       {
56792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56793       };
56794     } catch (std::exception& e) {
56795       {
56796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56797       };
56798     } catch (...) {
56799       {
56800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56801       };
56802     }
56803   }
56804 }
56805
56806
56807 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56808   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56809   bool (*arg2)() = (bool (*)()) 0 ;
56810
56811   arg1 = (Dali::Signal< bool () > *)jarg1;
56812   arg2 = (bool (*)())jarg2;
56813   {
56814     try {
56815       (arg1)->Disconnect(arg2);
56816     } catch (std::out_of_range& e) {
56817       {
56818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56819       };
56820     } catch (std::exception& e) {
56821       {
56822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56823       };
56824     } catch (...) {
56825       {
56826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56827       };
56828     }
56829   }
56830 }
56831
56832
56833 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
56834   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56835   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
56836   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
56837
56838   arg1 = (Dali::Signal< bool () > *)jarg1;
56839   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
56840   arg3 = (Dali::FunctorDelegate *)jarg3;
56841   {
56842     try {
56843       (arg1)->Connect(arg2,arg3);
56844     } catch (std::out_of_range& e) {
56845       {
56846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56847       };
56848     } catch (std::exception& e) {
56849       {
56850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56851       };
56852     } catch (...) {
56853       {
56854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56855       };
56856     }
56857   }
56858 }
56859
56860
56861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TimerSignalType_Emit(void * jarg1) {
56862   unsigned int jresult ;
56863   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56864   bool result;
56865
56866   arg1 = (Dali::Signal< bool () > *)jarg1;
56867   {
56868     try {
56869       result = (bool)(arg1)->Emit();
56870     } catch (std::out_of_range& e) {
56871       {
56872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56873       };
56874     } catch (std::exception& e) {
56875       {
56876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (...) {
56879       {
56880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56881       };
56882     }
56883   }
56884   jresult = result;
56885   return jresult;
56886 }
56887
56888
56889 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VISUAL_PROPERTY_TYPE_get() {
56890   int jresult ;
56891   int result;
56892
56893   {
56894     try {
56895       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56896     } catch (std::out_of_range& e) {
56897       {
56898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56899       };
56900     } catch (std::exception& e) {
56901       {
56902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (...) {
56905       {
56906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56907       };
56908     }
56909   }
56910   jresult = (int)result;
56911   return jresult;
56912 }
56913
56914
56915 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VISUAL_PROPERTY_SHADER_get() {
56916   int jresult ;
56917   int result;
56918
56919   {
56920     try {
56921       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56922     } catch (std::out_of_range& e) {
56923       {
56924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (std::exception& e) {
56927       {
56928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56933       };
56934     }
56935   }
56936   jresult = (int)result;
56937   return jresult;
56938 }
56939
56940
56941 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VERTEX_SHADER_get() {
56942   int jresult ;
56943   int result;
56944
56945   {
56946     try {
56947       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56948     } catch (std::out_of_range& e) {
56949       {
56950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56951       };
56952     } catch (std::exception& e) {
56953       {
56954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (...) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56959       };
56960     }
56961   }
56962   jresult = (int)result;
56963   return jresult;
56964 }
56965
56966
56967 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FRAGMENT_SHADER_get() {
56968   int jresult ;
56969   int result;
56970
56971   {
56972     try {
56973       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56974     } catch (std::out_of_range& e) {
56975       {
56976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56977       };
56978     } catch (std::exception& e) {
56979       {
56980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (...) {
56983       {
56984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56985       };
56986     }
56987   }
56988   jresult = (int)result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SUBDIVIDE_GRID_X_get() {
56994   int jresult ;
56995   int result;
56996
56997   {
56998     try {
56999       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (...) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57011       };
57012     }
57013   }
57014   jresult = (int)result;
57015   return jresult;
57016 }
57017
57018
57019 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SUBDIVIDE_GRID_Y_get() {
57020   int jresult ;
57021   int result;
57022
57023   {
57024     try {
57025       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57026     } catch (std::out_of_range& e) {
57027       {
57028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57029       };
57030     } catch (std::exception& e) {
57031       {
57032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57033       };
57034     } catch (...) {
57035       {
57036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57037       };
57038     }
57039   }
57040   jresult = (int)result;
57041   return jresult;
57042 }
57043
57044
57045 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_HINTS_get() {
57046   int jresult ;
57047   int result;
57048
57049   {
57050     try {
57051       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57052     } catch (std::out_of_range& e) {
57053       {
57054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57055       };
57056     } catch (std::exception& e) {
57057       {
57058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57059       };
57060     } catch (...) {
57061       {
57062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57063       };
57064     }
57065   }
57066   jresult = (int)result;
57067   return jresult;
57068 }
57069
57070
57071 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_COLOR_get() {
57072   int jresult ;
57073   int result;
57074
57075   {
57076     try {
57077       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57078     } catch (std::out_of_range& e) {
57079       {
57080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57081       };
57082     } catch (std::exception& e) {
57083       {
57084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57085       };
57086     } catch (...) {
57087       {
57088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57089       };
57090     }
57091   }
57092   jresult = (int)result;
57093   return jresult;
57094 }
57095
57096
57097 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SIZE_get() {
57098   int jresult ;
57099   int result;
57100
57101   {
57102     try {
57103       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57104     } catch (std::out_of_range& e) {
57105       {
57106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57107       };
57108     } catch (std::exception& e) {
57109       {
57110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (...) {
57113       {
57114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57115       };
57116     }
57117   }
57118   jresult = (int)result;
57119   return jresult;
57120 }
57121
57122
57123 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ANTI_ALIASING_get() {
57124   int jresult ;
57125   int result;
57126
57127   {
57128     try {
57129       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57130     } catch (std::out_of_range& e) {
57131       {
57132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57133       };
57134     } catch (std::exception& e) {
57135       {
57136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57137       };
57138     } catch (...) {
57139       {
57140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57141       };
57142     }
57143   }
57144   jresult = (int)result;
57145   return jresult;
57146 }
57147
57148
57149 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MIX_COLOR_get() {
57150   int jresult ;
57151   int result;
57152
57153   {
57154     try {
57155       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57156     } catch (std::out_of_range& e) {
57157       {
57158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57159       };
57160     } catch (std::exception& e) {
57161       {
57162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (...) {
57165       {
57166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57167       };
57168     }
57169   }
57170   jresult = (int)result;
57171   return jresult;
57172 }
57173
57174
57175 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_START_POSITION_get() {
57176   int jresult ;
57177   int result;
57178
57179   {
57180     try {
57181       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57182     } catch (std::out_of_range& e) {
57183       {
57184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57185       };
57186     } catch (std::exception& e) {
57187       {
57188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57189       };
57190     } catch (...) {
57191       {
57192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57193       };
57194     }
57195   }
57196   jresult = (int)result;
57197   return jresult;
57198 }
57199
57200
57201 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_END_POSITION_get() {
57202   int jresult ;
57203   int result;
57204
57205   {
57206     try {
57207       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57208     } catch (std::out_of_range& e) {
57209       {
57210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57211       };
57212     } catch (std::exception& e) {
57213       {
57214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57215       };
57216     } catch (...) {
57217       {
57218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57219       };
57220     }
57221   }
57222   jresult = (int)result;
57223   return jresult;
57224 }
57225
57226
57227 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CENTER_get() {
57228   int jresult ;
57229   int result;
57230
57231   {
57232     try {
57233       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57234     } catch (std::out_of_range& e) {
57235       {
57236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57237       };
57238     } catch (std::exception& e) {
57239       {
57240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57241       };
57242     } catch (...) {
57243       {
57244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57245       };
57246     }
57247   }
57248   jresult = (int)result;
57249   return jresult;
57250 }
57251
57252
57253 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RADIUS_get() {
57254   int jresult ;
57255   int result;
57256
57257   {
57258     try {
57259       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57260     } catch (std::out_of_range& e) {
57261       {
57262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57263       };
57264     } catch (std::exception& e) {
57265       {
57266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (...) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57271       };
57272     }
57273   }
57274   jresult = (int)result;
57275   return jresult;
57276 }
57277
57278
57279 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STOP_OFFSET_get() {
57280   int jresult ;
57281   int result;
57282
57283   {
57284     try {
57285       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57286     } catch (std::out_of_range& e) {
57287       {
57288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57289       };
57290     } catch (std::exception& e) {
57291       {
57292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57293       };
57294     } catch (...) {
57295       {
57296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57297       };
57298     }
57299   }
57300   jresult = (int)result;
57301   return jresult;
57302 }
57303
57304
57305 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STOP_COLOR_get() {
57306   int jresult ;
57307   int result;
57308
57309   {
57310     try {
57311       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57312     } catch (std::out_of_range& e) {
57313       {
57314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57315       };
57316     } catch (std::exception& e) {
57317       {
57318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57319       };
57320     } catch (...) {
57321       {
57322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57323       };
57324     }
57325   }
57326   jresult = (int)result;
57327   return jresult;
57328 }
57329
57330
57331 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_UNITS_get() {
57332   int jresult ;
57333   int result;
57334
57335   {
57336     try {
57337       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57338     } catch (std::out_of_range& e) {
57339       {
57340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57341       };
57342     } catch (std::exception& e) {
57343       {
57344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57345       };
57346     } catch (...) {
57347       {
57348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57349       };
57350     }
57351   }
57352   jresult = (int)result;
57353   return jresult;
57354 }
57355
57356
57357 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SPREAD_METHOD_get() {
57358   int jresult ;
57359   int result;
57360
57361   {
57362     try {
57363       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57364     } catch (std::out_of_range& e) {
57365       {
57366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57367       };
57368     } catch (std::exception& e) {
57369       {
57370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57371       };
57372     } catch (...) {
57373       {
57374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57375       };
57376     }
57377   }
57378   jresult = (int)result;
57379   return jresult;
57380 }
57381
57382
57383 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_URL_get() {
57384   int jresult ;
57385   int result;
57386
57387   {
57388     try {
57389       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57390     } catch (std::out_of_range& e) {
57391       {
57392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57393       };
57394     } catch (std::exception& e) {
57395       {
57396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57397       };
57398     } catch (...) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57401       };
57402     }
57403   }
57404   jresult = (int)result;
57405   return jresult;
57406 }
57407
57408
57409 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_FITTING_MODE_get() {
57410   int jresult ;
57411   int result;
57412
57413   {
57414     try {
57415       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57416     } catch (std::out_of_range& e) {
57417       {
57418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (std::exception& e) {
57421       {
57422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430   jresult = (int)result;
57431   return jresult;
57432 }
57433
57434
57435 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_SAMPLING_MODE_get() {
57436   int jresult ;
57437   int result;
57438
57439   {
57440     try {
57441       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57442     } catch (std::out_of_range& e) {
57443       {
57444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57445       };
57446     } catch (std::exception& e) {
57447       {
57448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (...) {
57451       {
57452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57453       };
57454     }
57455   }
57456   jresult = (int)result;
57457   return jresult;
57458 }
57459
57460
57461 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57462   int jresult ;
57463   int result;
57464
57465   {
57466     try {
57467       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57468     } catch (std::out_of_range& e) {
57469       {
57470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57471       };
57472     } catch (std::exception& e) {
57473       {
57474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57475       };
57476     } catch (...) {
57477       {
57478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57479       };
57480     }
57481   }
57482   jresult = (int)result;
57483   return jresult;
57484 }
57485
57486
57487 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57488   int jresult ;
57489   int result;
57490
57491   {
57492     try {
57493       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57505       };
57506     }
57507   }
57508   jresult = (int)result;
57509   return jresult;
57510 }
57511
57512
57513 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57514   int jresult ;
57515   int result;
57516
57517   {
57518     try {
57519       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534   jresult = (int)result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_BORDER_ONLY_get() {
57540   int jresult ;
57541   int result;
57542
57543   {
57544     try {
57545       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57546     } catch (std::out_of_range& e) {
57547       {
57548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57549       };
57550     } catch (std::exception& e) {
57551       {
57552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (...) {
57555       {
57556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57557       };
57558     }
57559   }
57560   jresult = (int)result;
57561   return jresult;
57562 }
57563
57564
57565 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_BATCHING_ENABLED_get() {
57566   int jresult ;
57567   int result;
57568
57569   {
57570     try {
57571       result = (int)Dali::Toolkit::ImageVisual::Property::BATCHING_ENABLED;
57572     } catch (std::out_of_range& e) {
57573       {
57574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (std::exception& e) {
57577       {
57578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (...) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57583       };
57584     }
57585   }
57586   jresult = (int)result;
57587   return jresult;
57588 }
57589
57590
57591 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_PIXEL_AREA_get() {
57592   int jresult ;
57593   int result;
57594
57595   {
57596     try {
57597       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57598     } catch (std::out_of_range& e) {
57599       {
57600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (std::exception& e) {
57603       {
57604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57609       };
57610     }
57611   }
57612   jresult = (int)result;
57613   return jresult;
57614 }
57615
57616
57617 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_WRAP_MODE_U_get() {
57618   int jresult ;
57619   int result;
57620
57621   {
57622     try {
57623       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57624     } catch (std::out_of_range& e) {
57625       {
57626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (std::exception& e) {
57629       {
57630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57635       };
57636     }
57637   }
57638   jresult = (int)result;
57639   return jresult;
57640 }
57641
57642
57643 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_WRAP_MODE_V_get() {
57644   int jresult ;
57645   int result;
57646
57647   {
57648     try {
57649       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57650     } catch (std::out_of_range& e) {
57651       {
57652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57653       };
57654     } catch (std::exception& e) {
57655       {
57656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (...) {
57659       {
57660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57661       };
57662     }
57663   }
57664   jresult = (int)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_OBJECT_URL_get() {
57670   int jresult ;
57671   int result;
57672
57673   {
57674     try {
57675       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57676     } catch (std::out_of_range& e) {
57677       {
57678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57679       };
57680     } catch (std::exception& e) {
57681       {
57682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57687       };
57688     }
57689   }
57690   jresult = (int)result;
57691   return jresult;
57692 }
57693
57694
57695 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MATERIAL_URL_get() {
57696   int jresult ;
57697   int result;
57698
57699   {
57700     try {
57701       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57702     } catch (std::out_of_range& e) {
57703       {
57704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57705       };
57706     } catch (std::exception& e) {
57707       {
57708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (...) {
57711       {
57712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57713       };
57714     }
57715   }
57716   jresult = (int)result;
57717   return jresult;
57718 }
57719
57720
57721 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXTURES_PATH_get() {
57722   int jresult ;
57723   int result;
57724
57725   {
57726     try {
57727       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57728     } catch (std::out_of_range& e) {
57729       {
57730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57731       };
57732     } catch (std::exception& e) {
57733       {
57734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57739       };
57740     }
57741   }
57742   jresult = (int)result;
57743   return jresult;
57744 }
57745
57746
57747 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SHADING_MODE_get() {
57748   int jresult ;
57749   int result;
57750
57751   {
57752     try {
57753       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57765       };
57766     }
57767   }
57768   jresult = (int)result;
57769   return jresult;
57770 }
57771
57772
57773 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_USE_MIPMAPPING_get() {
57774   int jresult ;
57775   int result;
57776
57777   {
57778     try {
57779       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57791       };
57792     }
57793   }
57794   jresult = (int)result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_USE_SOFT_NORMALS_get() {
57800   int jresult ;
57801   int result;
57802
57803   {
57804     try {
57805       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57806     } catch (std::out_of_range& e) {
57807       {
57808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57809       };
57810     } catch (std::exception& e) {
57811       {
57812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57813       };
57814     } catch (...) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57817       };
57818     }
57819   }
57820   jresult = (int)result;
57821   return jresult;
57822 }
57823
57824
57825 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LIGHT_POSITION_get() {
57826   int jresult ;
57827   int result;
57828
57829   {
57830     try {
57831       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57843       };
57844     }
57845   }
57846   jresult = (int)result;
57847   return jresult;
57848 }
57849
57850
57851 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SHAPE_get() {
57852   int jresult ;
57853   int result;
57854
57855   {
57856     try {
57857       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57858     } catch (std::out_of_range& e) {
57859       {
57860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (std::exception& e) {
57863       {
57864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57865       };
57866     } catch (...) {
57867       {
57868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57869       };
57870     }
57871   }
57872   jresult = (int)result;
57873   return jresult;
57874 }
57875
57876
57877 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57878   int jresult ;
57879   int result;
57880
57881   {
57882     try {
57883       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (...) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57895       };
57896     }
57897   }
57898   jresult = (int)result;
57899   return jresult;
57900 }
57901
57902
57903 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SLICES_get() {
57904   int jresult ;
57905   int result;
57906
57907   {
57908     try {
57909       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57910     } catch (std::out_of_range& e) {
57911       {
57912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57913       };
57914     } catch (std::exception& e) {
57915       {
57916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (...) {
57919       {
57920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57921       };
57922     }
57923   }
57924   jresult = (int)result;
57925   return jresult;
57926 }
57927
57928
57929 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STACKS_get() {
57930   int jresult ;
57931   int result;
57932
57933   {
57934     try {
57935       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57936     } catch (std::out_of_range& e) {
57937       {
57938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57939       };
57940     } catch (std::exception& e) {
57941       {
57942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (...) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57947       };
57948     }
57949   }
57950   jresult = (int)result;
57951   return jresult;
57952 }
57953
57954
57955 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_TOP_RADIUS_get() {
57956   int jresult ;
57957   int result;
57958
57959   {
57960     try {
57961       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57962     } catch (std::out_of_range& e) {
57963       {
57964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (std::exception& e) {
57967       {
57968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976   jresult = (int)result;
57977   return jresult;
57978 }
57979
57980
57981 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_BOTTOM_RADIUS_get() {
57982   int jresult ;
57983   int result;
57984
57985   {
57986     try {
57987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57999       };
58000     }
58001   }
58002   jresult = (int)result;
58003   return jresult;
58004 }
58005
58006
58007 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_HEIGHT_get() {
58008   int jresult ;
58009   int result;
58010
58011   {
58012     try {
58013       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58014     } catch (std::out_of_range& e) {
58015       {
58016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58017       };
58018     } catch (std::exception& e) {
58019       {
58020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (...) {
58023       {
58024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58025       };
58026     }
58027   }
58028   jresult = (int)result;
58029   return jresult;
58030 }
58031
58032
58033 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_RADIUS_get() {
58034   int jresult ;
58035   int result;
58036
58037   {
58038     try {
58039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58040     } catch (std::out_of_range& e) {
58041       {
58042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58043       };
58044     } catch (std::exception& e) {
58045       {
58046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58051       };
58052     }
58053   }
58054   jresult = (int)result;
58055   return jresult;
58056 }
58057
58058
58059 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_DIMENSIONS_get() {
58060   int jresult ;
58061   int result;
58062
58063   {
58064     try {
58065       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (...) {
58075       {
58076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58077       };
58078     }
58079   }
58080   jresult = (int)result;
58081   return jresult;
58082 }
58083
58084
58085 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BEVEL_PERCENTAGE_get() {
58086   int jresult ;
58087   int result;
58088
58089   {
58090     try {
58091       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58092     } catch (std::out_of_range& e) {
58093       {
58094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58095       };
58096     } catch (std::exception& e) {
58097       {
58098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58099       };
58100     } catch (...) {
58101       {
58102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58103       };
58104     }
58105   }
58106   jresult = (int)result;
58107   return jresult;
58108 }
58109
58110
58111 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BEVEL_SMOOTHNESS_get() {
58112   int jresult ;
58113   int result;
58114
58115   {
58116     try {
58117       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58118     } catch (std::out_of_range& e) {
58119       {
58120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58121       };
58122     } catch (std::exception& e) {
58123       {
58124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (...) {
58127       {
58128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58129       };
58130     }
58131   }
58132   jresult = (int)result;
58133   return jresult;
58134 }
58135
58136
58137 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58138   int jresult ;
58139   int result;
58140
58141   {
58142     try {
58143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58144     } catch (std::out_of_range& e) {
58145       {
58146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58147       };
58148     } catch (std::exception& e) {
58149       {
58150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (...) {
58153       {
58154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58155       };
58156     }
58157   }
58158   jresult = (int)result;
58159   return jresult;
58160 }
58161
58162 /* this should be fixed after tizen branch being upgraded!
58163 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXT_get() {
58164   int jresult ;
58165   int result;
58166
58167   {
58168     try {
58169       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184   jresult = (int)result;
58185   return jresult;
58186 }
58187
58188
58189 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FONT_FAMILY_get() {
58190   int jresult ;
58191   int result;
58192
58193   {
58194     try {
58195       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58196     } catch (std::out_of_range& e) {
58197       {
58198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58199       };
58200     } catch (std::exception& e) {
58201       {
58202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (...) {
58205       {
58206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58207       };
58208     }
58209   }
58210   jresult = (int)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FONT_STYLE_get() {
58216   int jresult ;
58217   int result;
58218
58219   {
58220     try {
58221       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236   jresult = (int)result;
58237   return jresult;
58238 }
58239
58240
58241 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_POINT_SIZE_get() {
58242   int jresult ;
58243   int result;
58244
58245   {
58246     try {
58247       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58248     } catch (std::out_of_range& e) {
58249       {
58250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58251       };
58252     } catch (std::exception& e) {
58253       {
58254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (...) {
58257       {
58258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58259       };
58260     }
58261   }
58262   jresult = (int)result;
58263   return jresult;
58264 }
58265
58266
58267 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MULTI_LINE_get() {
58268   int jresult ;
58269   int result;
58270
58271   {
58272     try {
58273       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58274     } catch (std::out_of_range& e) {
58275       {
58276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58277       };
58278     } catch (std::exception& e) {
58279       {
58280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (...) {
58283       {
58284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58285       };
58286     }
58287   }
58288   jresult = (int)result;
58289   return jresult;
58290 }
58291
58292
58293 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_HORIZONTAL_ALIGNMENT_get() {
58294   int jresult ;
58295   int result;
58296
58297   {
58298     try {
58299       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58300     } catch (std::out_of_range& e) {
58301       {
58302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (std::exception& e) {
58305       {
58306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314   jresult = (int)result;
58315   return jresult;
58316 }
58317
58318
58319 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VERTICAL_ALIGNMENT_get() {
58320   int jresult ;
58321   int result;
58322
58323   {
58324     try {
58325       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58326     } catch (std::out_of_range& e) {
58327       {
58328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58329       };
58330     } catch (std::exception& e) {
58331       {
58332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58337       };
58338     }
58339   }
58340   jresult = (int)result;
58341   return jresult;
58342 }
58343
58344
58345 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXT_COLOR_get() {
58346   int jresult ;
58347   int result;
58348
58349   {
58350     try {
58351       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58352     } catch (std::out_of_range& e) {
58353       {
58354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58355       };
58356     } catch (std::exception& e) {
58357       {
58358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (...) {
58361       {
58362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58363       };
58364     }
58365   }
58366   jresult = (int)result;
58367   return jresult;
58368 }
58369
58370
58371 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ENABLE_MARKUP_get() {
58372   int jresult ;
58373   int result;
58374
58375   {
58376     try {
58377       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58378     } catch (std::out_of_range& e) {
58379       {
58380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58381       };
58382     } catch (std::exception& e) {
58383       {
58384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58389       };
58390     }
58391   }
58392   jresult = (int)result;
58393   return jresult;
58394 }
58395 */
58396
58397 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Builder() {
58398   void * jresult ;
58399   Dali::Toolkit::Builder *result = 0 ;
58400
58401   {
58402     try {
58403       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58404     } catch (std::out_of_range& e) {
58405       {
58406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58407       };
58408     } catch (std::exception& e) {
58409       {
58410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (...) {
58413       {
58414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58415       };
58416     }
58417   }
58418   jresult = (void *)result;
58419   return jresult;
58420 }
58421
58422
58423 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_New() {
58424   void * jresult ;
58425   Dali::Toolkit::Builder result;
58426
58427   {
58428     try {
58429       result = Dali::Toolkit::Builder::New();
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (...) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58441       };
58442     }
58443   }
58444   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58445   return jresult;
58446 }
58447
58448
58449 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Builder(void * jarg1) {
58450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58451
58452   arg1 = (Dali::Toolkit::Builder *)jarg1;
58453   {
58454     try {
58455       delete arg1;
58456     } catch (std::out_of_range& e) {
58457       {
58458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58459       };
58460     } catch (std::exception& e) {
58461       {
58462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58467       };
58468     }
58469   }
58470 }
58471
58472
58473 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58475   std::string *arg2 = 0 ;
58476   Dali::Toolkit::Builder::UIFormat arg3 ;
58477
58478   arg1 = (Dali::Toolkit::Builder *)jarg1;
58479   if (!jarg2) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58481     return ;
58482   }
58483   std::string arg2_str(jarg2);
58484   arg2 = &arg2_str;
58485   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58486   {
58487     try {
58488       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58489     } catch (std::out_of_range& e) {
58490       {
58491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58492       };
58493     } catch (std::exception& e) {
58494       {
58495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58500       };
58501     }
58502   }
58503
58504   //argout typemap for const std::string&
58505
58506 }
58507
58508
58509 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58510   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58511   std::string *arg2 = 0 ;
58512
58513   arg1 = (Dali::Toolkit::Builder *)jarg1;
58514   if (!jarg2) {
58515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58516     return ;
58517   }
58518   std::string arg2_str(jarg2);
58519   arg2 = &arg2_str;
58520   {
58521     try {
58522       (arg1)->LoadFromString((std::string const &)*arg2);
58523     } catch (std::out_of_range& e) {
58524       {
58525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58526       };
58527     } catch (std::exception& e) {
58528       {
58529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58534       };
58535     }
58536   }
58537
58538   //argout typemap for const std::string&
58539
58540 }
58541
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddConstants(void * jarg1, void * jarg2) {
58544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58545   Dali::Property::Map *arg2 = 0 ;
58546
58547   arg1 = (Dali::Toolkit::Builder *)jarg1;
58548   arg2 = (Dali::Property::Map *)jarg2;
58549   if (!arg2) {
58550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58551     return ;
58552   }
58553   {
58554     try {
58555       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58556     } catch (std::out_of_range& e) {
58557       {
58558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58559       };
58560     } catch (std::exception& e) {
58561       {
58562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58567       };
58568     }
58569   }
58570 }
58571
58572
58573 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58574   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58575   std::string *arg2 = 0 ;
58576   Dali::Property::Value *arg3 = 0 ;
58577
58578   arg1 = (Dali::Toolkit::Builder *)jarg1;
58579   if (!jarg2) {
58580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58581     return ;
58582   }
58583   std::string arg2_str(jarg2);
58584   arg2 = &arg2_str;
58585   arg3 = (Dali::Property::Value *)jarg3;
58586   if (!arg3) {
58587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58588     return ;
58589   }
58590   {
58591     try {
58592       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (...) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58604       };
58605     }
58606   }
58607
58608   //argout typemap for const std::string&
58609
58610 }
58611
58612
58613 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetConstants(void * jarg1) {
58614   void * jresult ;
58615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58616   Dali::Property::Map *result = 0 ;
58617
58618   arg1 = (Dali::Toolkit::Builder *)jarg1;
58619   {
58620     try {
58621       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58622     } catch (std::out_of_range& e) {
58623       {
58624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58625       };
58626     } catch (std::exception& e) {
58627       {
58628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (...) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58633       };
58634     }
58635   }
58636   jresult = (void *)result;
58637   return jresult;
58638 }
58639
58640
58641 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetConstant(void * jarg1, char * jarg2) {
58642   void * jresult ;
58643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58644   std::string *arg2 = 0 ;
58645   Dali::Property::Value *result = 0 ;
58646
58647   arg1 = (Dali::Toolkit::Builder *)jarg1;
58648   if (!jarg2) {
58649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58650     return 0;
58651   }
58652   std::string arg2_str(jarg2);
58653   arg2 = &arg2_str;
58654   {
58655     try {
58656       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58668       };
58669     }
58670   }
58671   jresult = (void *)result;
58672
58673   //argout typemap for const std::string&
58674
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58680   void * jresult ;
58681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58682   std::string *arg2 = 0 ;
58683   Dali::Animation result;
58684
58685   arg1 = (Dali::Toolkit::Builder *)jarg1;
58686   if (!jarg2) {
58687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58688     return 0;
58689   }
58690   std::string arg2_str(jarg2);
58691   arg2 = &arg2_str;
58692   {
58693     try {
58694       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709   jresult = new Dali::Animation((const Dali::Animation &)result);
58710
58711   //argout typemap for const std::string&
58712
58713   return jresult;
58714 }
58715
58716
58717 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58718   void * jresult ;
58719   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58720   std::string *arg2 = 0 ;
58721   Dali::Property::Map *arg3 = 0 ;
58722   Dali::Animation result;
58723
58724   arg1 = (Dali::Toolkit::Builder *)jarg1;
58725   if (!jarg2) {
58726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58727     return 0;
58728   }
58729   std::string arg2_str(jarg2);
58730   arg2 = &arg2_str;
58731   arg3 = (Dali::Property::Map *)jarg3;
58732   if (!arg3) {
58733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58734     return 0;
58735   }
58736   {
58737     try {
58738       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (...) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58750       };
58751     }
58752   }
58753   jresult = new Dali::Animation((const Dali::Animation &)result);
58754
58755   //argout typemap for const std::string&
58756
58757   return jresult;
58758 }
58759
58760
58761 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58762   void * jresult ;
58763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58764   std::string *arg2 = 0 ;
58765   Dali::Actor arg3 ;
58766   Dali::Actor *argp3 ;
58767   Dali::Animation result;
58768
58769   arg1 = (Dali::Toolkit::Builder *)jarg1;
58770   if (!jarg2) {
58771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58772     return 0;
58773   }
58774   std::string arg2_str(jarg2);
58775   arg2 = &arg2_str;
58776   argp3 = (Dali::Actor *)jarg3;
58777   if (!argp3) {
58778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58779     return 0;
58780   }
58781   arg3 = *argp3;
58782   {
58783     try {
58784       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58785     } catch (std::out_of_range& e) {
58786       {
58787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58788       };
58789     } catch (std::exception& e) {
58790       {
58791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58792       };
58793     } catch (...) {
58794       {
58795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58796       };
58797     }
58798   }
58799   jresult = new Dali::Animation((const Dali::Animation &)result);
58800
58801   //argout typemap for const std::string&
58802
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58808   void * jresult ;
58809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58810   std::string *arg2 = 0 ;
58811   Dali::Property::Map *arg3 = 0 ;
58812   Dali::Actor arg4 ;
58813   Dali::Actor *argp4 ;
58814   Dali::Animation result;
58815
58816   arg1 = (Dali::Toolkit::Builder *)jarg1;
58817   if (!jarg2) {
58818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58819     return 0;
58820   }
58821   std::string arg2_str(jarg2);
58822   arg2 = &arg2_str;
58823   arg3 = (Dali::Property::Map *)jarg3;
58824   if (!arg3) {
58825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58826     return 0;
58827   }
58828   argp4 = (Dali::Actor *)jarg4;
58829   if (!argp4) {
58830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58831     return 0;
58832   }
58833   arg4 = *argp4;
58834   {
58835     try {
58836       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (...) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58848       };
58849     }
58850   }
58851   jresult = new Dali::Animation((const Dali::Animation &)result);
58852
58853   //argout typemap for const std::string&
58854
58855   return jresult;
58856 }
58857
58858
58859 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58860   void * jresult ;
58861   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58862   std::string *arg2 = 0 ;
58863   Dali::BaseHandle result;
58864
58865   arg1 = (Dali::Toolkit::Builder *)jarg1;
58866   if (!jarg2) {
58867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58868     return 0;
58869   }
58870   std::string arg2_str(jarg2);
58871   arg2 = &arg2_str;
58872   {
58873     try {
58874       result = (arg1)->Create((std::string const &)*arg2);
58875     } catch (std::out_of_range& e) {
58876       {
58877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58878       };
58879     } catch (std::exception& e) {
58880       {
58881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58886       };
58887     }
58888   }
58889   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58890
58891   //argout typemap for const std::string&
58892
58893   return jresult;
58894 }
58895
58896
58897 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58898   void * jresult ;
58899   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58900   std::string *arg2 = 0 ;
58901   Dali::Property::Map *arg3 = 0 ;
58902   Dali::BaseHandle result;
58903
58904   arg1 = (Dali::Toolkit::Builder *)jarg1;
58905   if (!jarg2) {
58906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58907     return 0;
58908   }
58909   std::string arg2_str(jarg2);
58910   arg2 = &arg2_str;
58911   arg3 = (Dali::Property::Map *)jarg3;
58912   if (!arg3) {
58913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58914     return 0;
58915   }
58916   {
58917     try {
58918       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (...) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58930       };
58931     }
58932   }
58933   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58934
58935   //argout typemap for const std::string&
58936
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58942   void * jresult ;
58943   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58944   std::string *arg2 = 0 ;
58945   Dali::BaseHandle result;
58946
58947   arg1 = (Dali::Toolkit::Builder *)jarg1;
58948   if (!jarg2) {
58949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58950     return 0;
58951   }
58952   std::string arg2_str(jarg2);
58953   arg2 = &arg2_str;
58954   {
58955     try {
58956       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58957     } catch (std::out_of_range& e) {
58958       {
58959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (std::exception& e) {
58962       {
58963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58972
58973   //argout typemap for const std::string&
58974
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58980   unsigned int jresult ;
58981   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58982   std::string *arg2 = 0 ;
58983   Dali::Handle *arg3 = 0 ;
58984   bool result;
58985
58986   arg1 = (Dali::Toolkit::Builder *)jarg1;
58987   if (!jarg2) {
58988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58989     return 0;
58990   }
58991   std::string arg2_str(jarg2);
58992   arg2 = &arg2_str;
58993   arg3 = (Dali::Handle *)jarg3;
58994   if (!arg3) {
58995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58996     return 0;
58997   }
58998   {
58999     try {
59000       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
59001     } catch (std::out_of_range& e) {
59002       {
59003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59004       };
59005     } catch (std::exception& e) {
59006       {
59007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (...) {
59010       {
59011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59012       };
59013     }
59014   }
59015   jresult = result;
59016
59017   //argout typemap for const std::string&
59018
59019   return jresult;
59020 }
59021
59022
59023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59024   unsigned int jresult ;
59025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59026   Dali::Handle *arg2 = 0 ;
59027   std::string *arg3 = 0 ;
59028   bool result;
59029
59030   arg1 = (Dali::Toolkit::Builder *)jarg1;
59031   arg2 = (Dali::Handle *)jarg2;
59032   if (!arg2) {
59033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59034     return 0;
59035   }
59036   if (!jarg3) {
59037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59038     return 0;
59039   }
59040   std::string arg3_str(jarg3);
59041   arg3 = &arg3_str;
59042   {
59043     try {
59044       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59045     } catch (std::out_of_range& e) {
59046       {
59047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (std::exception& e) {
59050       {
59051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (...) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59056       };
59057     }
59058   }
59059   jresult = result;
59060
59061   //argout typemap for const std::string&
59062
59063   return jresult;
59064 }
59065
59066
59067 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59068   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59069   Dali::Actor arg2 ;
59070   Dali::Actor *argp2 ;
59071
59072   arg1 = (Dali::Toolkit::Builder *)jarg1;
59073   argp2 = (Dali::Actor *)jarg2;
59074   if (!argp2) {
59075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59076     return ;
59077   }
59078   arg2 = *argp2;
59079   {
59080     try {
59081       (arg1)->AddActors(arg2);
59082     } catch (std::out_of_range& e) {
59083       {
59084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (std::exception& e) {
59087       {
59088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096 }
59097
59098
59099 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59101   std::string *arg2 = 0 ;
59102   Dali::Actor arg3 ;
59103   Dali::Actor *argp3 ;
59104
59105   arg1 = (Dali::Toolkit::Builder *)jarg1;
59106   if (!jarg2) {
59107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59108     return ;
59109   }
59110   std::string arg2_str(jarg2);
59111   arg2 = &arg2_str;
59112   argp3 = (Dali::Actor *)jarg3;
59113   if (!argp3) {
59114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59115     return ;
59116   }
59117   arg3 = *argp3;
59118   {
59119     try {
59120       (arg1)->AddActors((std::string const &)*arg2,arg3);
59121     } catch (std::out_of_range& e) {
59122       {
59123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59124       };
59125     } catch (std::exception& e) {
59126       {
59127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (...) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59132       };
59133     }
59134   }
59135
59136   //argout typemap for const std::string&
59137
59138 }
59139
59140
59141 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59142   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59143   std::string *arg2 = 0 ;
59144
59145   arg1 = (Dali::Toolkit::Builder *)jarg1;
59146   if (!jarg2) {
59147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59148     return ;
59149   }
59150   std::string arg2_str(jarg2);
59151   arg2 = &arg2_str;
59152   {
59153     try {
59154       (arg1)->CreateRenderTask((std::string const &)*arg2);
59155     } catch (std::out_of_range& e) {
59156       {
59157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59158       };
59159     } catch (std::exception& e) {
59160       {
59161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59162       };
59163     } catch (...) {
59164       {
59165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59166       };
59167     }
59168   }
59169
59170   //argout typemap for const std::string&
59171
59172 }
59173
59174
59175 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59176   void * jresult ;
59177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59178   std::string *arg2 = 0 ;
59179   Dali::FrameBufferImage result;
59180
59181   arg1 = (Dali::Toolkit::Builder *)jarg1;
59182   if (!jarg2) {
59183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59184     return 0;
59185   }
59186   std::string arg2_str(jarg2);
59187   arg2 = &arg2_str;
59188   {
59189     try {
59190       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59191     } catch (std::out_of_range& e) {
59192       {
59193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59194       };
59195     } catch (std::exception& e) {
59196       {
59197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59202       };
59203     }
59204   }
59205   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59206
59207   //argout typemap for const std::string&
59208
59209   return jresult;
59210 }
59211
59212
59213 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetPath(void * jarg1, char * jarg2) {
59214   void * jresult ;
59215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59216   std::string *arg2 = 0 ;
59217   Dali::Path result;
59218
59219   arg1 = (Dali::Toolkit::Builder *)jarg1;
59220   if (!jarg2) {
59221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59222     return 0;
59223   }
59224   std::string arg2_str(jarg2);
59225   arg2 = &arg2_str;
59226   {
59227     try {
59228       result = (arg1)->GetPath((std::string const &)*arg2);
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59240       };
59241     }
59242   }
59243   jresult = new Dali::Path((const Dali::Path &)result);
59244
59245   //argout typemap for const std::string&
59246
59247   return jresult;
59248 }
59249
59250
59251 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59252   void * jresult ;
59253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59254   std::string *arg2 = 0 ;
59255   Dali::PathConstrainer result;
59256
59257   arg1 = (Dali::Toolkit::Builder *)jarg1;
59258   if (!jarg2) {
59259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59260     return 0;
59261   }
59262   std::string arg2_str(jarg2);
59263   arg2 = &arg2_str;
59264   {
59265     try {
59266       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (...) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59278       };
59279     }
59280   }
59281   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59282
59283   //argout typemap for const std::string&
59284
59285   return jresult;
59286 }
59287
59288
59289 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59290   void * jresult ;
59291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59292   std::string *arg2 = 0 ;
59293   Dali::LinearConstrainer result;
59294
59295   arg1 = (Dali::Toolkit::Builder *)jarg1;
59296   if (!jarg2) {
59297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59298     return 0;
59299   }
59300   std::string arg2_str(jarg2);
59301   arg2 = &arg2_str;
59302   {
59303     try {
59304       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59305     } catch (std::out_of_range& e) {
59306       {
59307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59308       };
59309     } catch (std::exception& e) {
59310       {
59311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (...) {
59314       {
59315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59316       };
59317     }
59318   }
59319   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59320
59321   //argout typemap for const std::string&
59322
59323   return jresult;
59324 }
59325
59326
59327 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_QuitSignal(void * jarg1) {
59328   void * jresult ;
59329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59330   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59331
59332   arg1 = (Dali::Toolkit::Builder *)jarg1;
59333   {
59334     try {
59335       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59336     } catch (std::out_of_range& e) {
59337       {
59338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (std::exception& e) {
59341       {
59342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (...) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59347       };
59348     }
59349   }
59350   jresult = (void *)result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_0() {
59356   void * jresult ;
59357   Dali::Toolkit::TransitionData *result = 0 ;
59358
59359   {
59360     try {
59361       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59373       };
59374     }
59375   }
59376   jresult = (void *)result;
59377   return jresult;
59378 }
59379
59380
59381 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TransitionData(void * jarg1) {
59382   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59383
59384   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59385   {
59386     try {
59387       delete arg1;
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402 }
59403
59404
59405 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_New__SWIG_0(void * jarg1) {
59406   void * jresult ;
59407   Dali::Property::Map *arg1 = 0 ;
59408   Dali::Toolkit::TransitionData result;
59409
59410   arg1 = (Dali::Property::Map *)jarg1;
59411   if (!arg1) {
59412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59413     return 0;
59414   }
59415   {
59416     try {
59417       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59433   return jresult;
59434 }
59435
59436
59437 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_New__SWIG_1(void * jarg1) {
59438   void * jresult ;
59439   Dali::Property::Array *arg1 = 0 ;
59440   Dali::Toolkit::TransitionData result;
59441
59442   arg1 = (Dali::Property::Array *)jarg1;
59443   if (!arg1) {
59444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59445     return 0;
59446   }
59447   {
59448     try {
59449       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59450     } catch (std::out_of_range& e) {
59451       {
59452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (std::exception& e) {
59455       {
59456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_DownCast(void * jarg1) {
59470   void * jresult ;
59471   Dali::BaseHandle arg1 ;
59472   Dali::BaseHandle *argp1 ;
59473   Dali::Toolkit::TransitionData result;
59474
59475   argp1 = (Dali::BaseHandle *)jarg1;
59476   if (!argp1) {
59477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59478     return 0;
59479   }
59480   arg1 = *argp1;
59481   {
59482     try {
59483       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (...) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59495       };
59496     }
59497   }
59498   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_1(void * jarg1) {
59504   void * jresult ;
59505   Dali::Toolkit::TransitionData *arg1 = 0 ;
59506   Dali::Toolkit::TransitionData *result = 0 ;
59507
59508   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59509   if (!arg1) {
59510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59511     return 0;
59512   }
59513   {
59514     try {
59515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59516     } catch (std::out_of_range& e) {
59517       {
59518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59519       };
59520     } catch (std::exception& e) {
59521       {
59522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (...) {
59525       {
59526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59527       };
59528     }
59529   }
59530   jresult = (void *)result;
59531   return jresult;
59532 }
59533
59534
59535 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_Assign(void * jarg1, void * jarg2) {
59536   void * jresult ;
59537   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59538   Dali::Toolkit::TransitionData *arg2 = 0 ;
59539   Dali::Toolkit::TransitionData *result = 0 ;
59540
59541   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59542   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59543   if (!arg2) {
59544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59545     return 0;
59546   }
59547   {
59548     try {
59549       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59550     } catch (std::out_of_range& e) {
59551       {
59552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (std::exception& e) {
59555       {
59556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564   jresult = (void *)result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TransitionData_Count(void * jarg1) {
59570   unsigned long jresult ;
59571   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59572   size_t result;
59573
59574   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59575   {
59576     try {
59577       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59578     } catch (std::out_of_range& e) {
59579       {
59580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59581       };
59582     } catch (std::exception& e) {
59583       {
59584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59585       };
59586     } catch (...) {
59587       {
59588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59589       };
59590     }
59591   }
59592   jresult = (unsigned long)result;
59593   return jresult;
59594 }
59595
59596
59597 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59598   void * jresult ;
59599   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59600   size_t arg2 ;
59601   Dali::Property::Map result;
59602
59603   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59604   arg2 = (size_t)jarg2;
59605   {
59606     try {
59607       result = (arg1)->GetAnimatorAt(arg2);
59608     } catch (std::out_of_range& e) {
59609       {
59610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (std::exception& e) {
59613       {
59614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (...) {
59617       {
59618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59619       };
59620     }
59621   }
59622   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_2(void * jarg1) {
59628   void * jresult ;
59629   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59630   Dali::Toolkit::TransitionData *result = 0 ;
59631
59632   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59633   {
59634     try {
59635       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59636     } catch (std::out_of_range& e) {
59637       {
59638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59639       };
59640     } catch (std::exception& e) {
59641       {
59642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (...) {
59645       {
59646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59647       };
59648     }
59649   }
59650   jresult = (void *)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_New() {
59656   void * jresult ;
59657   Dali::Toolkit::Control result;
59658
59659   {
59660     try {
59661       result = Dali::Toolkit::Internal::Control::New();
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59677   return jresult;
59678 }
59679
59680
59681 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59683   std::string *arg2 = 0 ;
59684
59685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59686   if (!jarg2) {
59687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59688     return ;
59689   }
59690   std::string arg2_str(jarg2);
59691   arg2 = &arg2_str;
59692   {
59693     try {
59694       (arg1)->SetStyleName((std::string const &)*arg2);
59695     } catch (std::out_of_range& e) {
59696       {
59697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59698       };
59699     } catch (std::exception& e) {
59700       {
59701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59702       };
59703     } catch (...) {
59704       {
59705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59706       };
59707     }
59708   }
59709
59710   //argout typemap for const std::string&
59711
59712 }
59713
59714
59715 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_ViewImpl_GetStyleName(void * jarg1) {
59716   char * jresult ;
59717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59718   std::string *result = 0 ;
59719
59720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59721   {
59722     try {
59723       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59724     } catch (std::out_of_range& e) {
59725       {
59726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59727       };
59728     } catch (std::exception& e) {
59729       {
59730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59731       };
59732     } catch (...) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59735       };
59736     }
59737   }
59738   jresult = SWIG_csharp_string_callback(result->c_str());
59739   return jresult;
59740 }
59741
59742
59743 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59745   Dali::Vector4 *arg2 = 0 ;
59746
59747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59748   arg2 = (Dali::Vector4 *)jarg2;
59749   if (!arg2) {
59750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59751     return ;
59752   }
59753   {
59754     try {
59755       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59756     } catch (std::out_of_range& e) {
59757       {
59758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59759       };
59760     } catch (std::exception& e) {
59761       {
59762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59763       };
59764     } catch (...) {
59765       {
59766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59767       };
59768     }
59769   }
59770 }
59771
59772
59773 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetBackgroundColor(void * jarg1) {
59774   void * jresult ;
59775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59776   Dali::Vector4 result;
59777
59778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59779   {
59780     try {
59781       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59782     } catch (std::out_of_range& e) {
59783       {
59784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59785       };
59786     } catch (std::exception& e) {
59787       {
59788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (...) {
59791       {
59792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59793       };
59794     }
59795   }
59796   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59797   return jresult;
59798 }
59799
59800
59801 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59803   Dali::Image arg2 ;
59804   Dali::Image *argp2 ;
59805
59806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59807   argp2 = (Dali::Image *)jarg2;
59808   if (!argp2) {
59809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59810     return ;
59811   }
59812   arg2 = *argp2;
59813   {
59814     try {
59815       (arg1)->SetBackgroundImage(arg2);
59816     } catch (std::out_of_range& e) {
59817       {
59818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59819       };
59820     } catch (std::exception& e) {
59821       {
59822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59823       };
59824     } catch (...) {
59825       {
59826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59827       };
59828     }
59829   }
59830 }
59831
59832
59833 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59835   Dali::Property::Map *arg2 = 0 ;
59836
59837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59838   arg2 = (Dali::Property::Map *)jarg2;
59839   if (!arg2) {
59840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59841     return ;
59842   }
59843   {
59844     try {
59845       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59853       };
59854     } catch (...) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59857       };
59858     }
59859   }
59860 }
59861
59862
59863 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_ClearBackground(void * jarg1) {
59864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59865
59866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59867   {
59868     try {
59869       (arg1)->ClearBackground();
59870     } catch (std::out_of_range& e) {
59871       {
59872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59873       };
59874     } catch (std::exception& e) {
59875       {
59876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59877       };
59878     } catch (...) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59881       };
59882     }
59883   }
59884 }
59885
59886
59887 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59889   Dali::Gesture::Type arg2 ;
59890
59891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59892   arg2 = (Dali::Gesture::Type)jarg2;
59893   {
59894     try {
59895       (arg1)->EnableGestureDetection(arg2);
59896     } catch (std::out_of_range& e) {
59897       {
59898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59899       };
59900     } catch (std::exception& e) {
59901       {
59902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59903       };
59904     } catch (...) {
59905       {
59906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59907       };
59908     }
59909   }
59910 }
59911
59912
59913 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59915   Dali::Gesture::Type arg2 ;
59916
59917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59918   arg2 = (Dali::Gesture::Type)jarg2;
59919   {
59920     try {
59921       (arg1)->DisableGestureDetection(arg2);
59922     } catch (std::out_of_range& e) {
59923       {
59924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59925       };
59926     } catch (std::exception& e) {
59927       {
59928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59929       };
59930     } catch (...) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59933       };
59934     }
59935   }
59936 }
59937
59938
59939 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59940   void * jresult ;
59941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59942   Dali::PinchGestureDetector result;
59943
59944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59945   {
59946     try {
59947       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59948     } catch (std::out_of_range& e) {
59949       {
59950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59951       };
59952     } catch (std::exception& e) {
59953       {
59954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (...) {
59957       {
59958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59959       };
59960     }
59961   }
59962   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59963   return jresult;
59964 }
59965
59966
59967 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetPanGestureDetector(void * jarg1) {
59968   void * jresult ;
59969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59970   Dali::PanGestureDetector result;
59971
59972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59973   {
59974     try {
59975       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59976     } catch (std::out_of_range& e) {
59977       {
59978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59979       };
59980     } catch (std::exception& e) {
59981       {
59982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59983       };
59984     } catch (...) {
59985       {
59986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59987       };
59988     }
59989   }
59990   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59991   return jresult;
59992 }
59993
59994
59995 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetTapGestureDetector(void * jarg1) {
59996   void * jresult ;
59997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59998   Dali::TapGestureDetector result;
59999
60000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60001   {
60002     try {
60003       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60019   return jresult;
60020 }
60021
60022
60023 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60024   void * jresult ;
60025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60026   Dali::LongPressGestureDetector result;
60027
60028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60029   {
60030     try {
60031       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60032     } catch (std::out_of_range& e) {
60033       {
60034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (std::exception& e) {
60037       {
60038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60039       };
60040     } catch (...) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60043       };
60044     }
60045   }
60046   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60047   return jresult;
60048 }
60049
60050
60051 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60053   bool arg2 ;
60054
60055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60056   arg2 = jarg2 ? true : false;
60057   {
60058     try {
60059       (arg1)->SetKeyboardNavigationSupport(arg2);
60060     } catch (std::out_of_range& e) {
60061       {
60062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60063       };
60064     } catch (std::exception& e) {
60065       {
60066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60067       };
60068     } catch (...) {
60069       {
60070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60071       };
60072     }
60073   }
60074 }
60075
60076
60077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60078   unsigned int jresult ;
60079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60080   bool result;
60081
60082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60083   {
60084     try {
60085       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60086     } catch (std::out_of_range& e) {
60087       {
60088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60089       };
60090     } catch (std::exception& e) {
60091       {
60092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60093       };
60094     } catch (...) {
60095       {
60096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60097       };
60098     }
60099   }
60100   jresult = result;
60101   return jresult;
60102 }
60103
60104
60105 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetKeyInputFocus(void * jarg1) {
60106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60107
60108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60109   {
60110     try {
60111       (arg1)->SetKeyInputFocus();
60112     } catch (std::out_of_range& e) {
60113       {
60114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60115       };
60116     } catch (std::exception& e) {
60117       {
60118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60119       };
60120     } catch (...) {
60121       {
60122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60123       };
60124     }
60125   }
60126 }
60127
60128
60129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_HasKeyInputFocus(void * jarg1) {
60130   unsigned int jresult ;
60131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60132   bool result;
60133
60134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60135   {
60136     try {
60137       result = (bool)(arg1)->HasKeyInputFocus();
60138     } catch (std::out_of_range& e) {
60139       {
60140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60141       };
60142     } catch (std::exception& e) {
60143       {
60144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60145       };
60146     } catch (...) {
60147       {
60148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60149       };
60150     }
60151   }
60152   jresult = result;
60153   return jresult;
60154 }
60155
60156
60157 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60159
60160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60161   {
60162     try {
60163       (arg1)->ClearKeyInputFocus();
60164     } catch (std::out_of_range& e) {
60165       {
60166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60167       };
60168     } catch (std::exception& e) {
60169       {
60170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60171       };
60172     } catch (...) {
60173       {
60174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60175       };
60176     }
60177   }
60178 }
60179
60180
60181 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60183   bool arg2 ;
60184
60185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60186   arg2 = jarg2 ? true : false;
60187   {
60188     try {
60189       (arg1)->SetAsKeyboardFocusGroup(arg2);
60190     } catch (std::out_of_range& e) {
60191       {
60192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60193       };
60194     } catch (std::exception& e) {
60195       {
60196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60197       };
60198     } catch (...) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60201       };
60202     }
60203   }
60204 }
60205
60206
60207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60208   unsigned int jresult ;
60209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60210   bool result;
60211
60212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60213   {
60214     try {
60215       result = (bool)(arg1)->IsKeyboardFocusGroup();
60216     } catch (std::out_of_range& e) {
60217       {
60218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60219       };
60220     } catch (std::exception& e) {
60221       {
60222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60223       };
60224     } catch (...) {
60225       {
60226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60227       };
60228     }
60229   }
60230   jresult = result;
60231   return jresult;
60232 }
60233
60234
60235 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_AccessibilityActivate(void * jarg1) {
60236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60237
60238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60239   {
60240     try {
60241       (arg1)->AccessibilityActivate();
60242     } catch (std::out_of_range& e) {
60243       {
60244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60245       };
60246     } catch (std::exception& e) {
60247       {
60248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60249       };
60250     } catch (...) {
60251       {
60252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60253       };
60254     }
60255   }
60256 }
60257
60258
60259 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_KeyboardEnter(void * jarg1) {
60260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60261
60262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60263   {
60264     try {
60265       (arg1)->KeyboardEnter();
60266     } catch (std::out_of_range& e) {
60267       {
60268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60269       };
60270     } catch (std::exception& e) {
60271       {
60272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60273       };
60274     } catch (...) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60277       };
60278     }
60279   }
60280 }
60281
60282
60283 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyEventSignal(void * jarg1) {
60284   void * jresult ;
60285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60286   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60287
60288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60289   {
60290     try {
60291       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60292     } catch (std::out_of_range& e) {
60293       {
60294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60295       };
60296     } catch (std::exception& e) {
60297       {
60298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (...) {
60301       {
60302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60303       };
60304     }
60305   }
60306   jresult = (void *)result;
60307   return jresult;
60308 }
60309
60310
60311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60312   void * jresult ;
60313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60314   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60315
60316   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60317   {
60318     try {
60319       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60320     } catch (std::out_of_range& e) {
60321       {
60322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60323       };
60324     } catch (std::exception& e) {
60325       {
60326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (...) {
60329       {
60330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60331       };
60332     }
60333   }
60334   jresult = (void *)result;
60335   return jresult;
60336 }
60337
60338
60339 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60340   void * jresult ;
60341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60342   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60343
60344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60345   {
60346     try {
60347       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60348     } catch (std::out_of_range& e) {
60349       {
60350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60351       };
60352     } catch (std::exception& e) {
60353       {
60354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60355       };
60356     } catch (...) {
60357       {
60358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60359       };
60360     }
60361   }
60362   jresult = (void *)result;
60363   return jresult;
60364 }
60365
60366
60367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60368   unsigned int jresult ;
60369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60370   Dali::KeyEvent *arg2 = 0 ;
60371   bool result;
60372
60373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60374   arg2 = (Dali::KeyEvent *)jarg2;
60375   if (!arg2) {
60376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60377     return 0;
60378   }
60379   {
60380     try {
60381       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60382     } catch (std::out_of_range& e) {
60383       {
60384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (std::exception& e) {
60387       {
60388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (...) {
60391       {
60392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60393       };
60394     }
60395   }
60396   jresult = result;
60397   return jresult;
60398 }
60399
60400
60401 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60403   int arg2 ;
60404   SwigDirector_ViewImpl *darg = 0;
60405
60406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60407   arg2 = (int)jarg2;
60408   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60409   {
60410     try {
60411       (darg)->OnStageConnection(arg2);
60412     } catch (std::out_of_range& e) {
60413       {
60414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60415       };
60416     } catch (std::exception& e) {
60417       {
60418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60419       };
60420     } catch (...) {
60421       {
60422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60423       };
60424     }
60425   }
60426 }
60427
60428
60429 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60431   int arg2 ;
60432   SwigDirector_ViewImpl *darg = 0;
60433
60434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60435   arg2 = (int)jarg2;
60436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60437   {
60438     try {
60439       (darg)->OnStageConnectionSwigPublic(arg2);
60440     } catch (std::out_of_range& e) {
60441       {
60442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60443       };
60444     } catch (std::exception& e) {
60445       {
60446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60447       };
60448     } catch (...) {
60449       {
60450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60451       };
60452     }
60453   }
60454 }
60455
60456
60457 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageDisconnection(void * jarg1) {
60458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60459   SwigDirector_ViewImpl *darg = 0;
60460
60461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60462   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60463   {
60464     try {
60465       (darg)->OnStageDisconnection();
60466     } catch (std::out_of_range& e) {
60467       {
60468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60469       };
60470     } catch (std::exception& e) {
60471       {
60472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60473       };
60474     } catch (...) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60477       };
60478     }
60479   }
60480 }
60481
60482
60483 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60485   SwigDirector_ViewImpl *darg = 0;
60486
60487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60488   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60489   {
60490     try {
60491       (darg)->OnStageDisconnectionSwigPublic();
60492     } catch (std::out_of_range& e) {
60493       {
60494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60495       };
60496     } catch (std::exception& e) {
60497       {
60498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60499       };
60500     } catch (...) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60503       };
60504     }
60505   }
60506 }
60507
60508
60509 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60511   Dali::Actor *arg2 = 0 ;
60512   SwigDirector_ViewImpl *darg = 0;
60513
60514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60515   arg2 = (Dali::Actor *)jarg2;
60516   if (!arg2) {
60517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60518     return ;
60519   }
60520   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60521   {
60522     try {
60523       (darg)->OnChildAdd(*arg2);
60524     } catch (std::out_of_range& e) {
60525       {
60526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60527       };
60528     } catch (std::exception& e) {
60529       {
60530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60531       };
60532     } catch (...) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60535       };
60536     }
60537   }
60538 }
60539
60540
60541 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60543   Dali::Actor *arg2 = 0 ;
60544   SwigDirector_ViewImpl *darg = 0;
60545
60546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60547   arg2 = (Dali::Actor *)jarg2;
60548   if (!arg2) {
60549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60550     return ;
60551   }
60552   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60553   {
60554     try {
60555       (darg)->OnChildAddSwigPublic(*arg2);
60556     } catch (std::out_of_range& e) {
60557       {
60558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60559       };
60560     } catch (std::exception& e) {
60561       {
60562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60563       };
60564     } catch (...) {
60565       {
60566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60567       };
60568     }
60569   }
60570 }
60571
60572
60573 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60575   Dali::Actor *arg2 = 0 ;
60576   SwigDirector_ViewImpl *darg = 0;
60577
60578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60579   arg2 = (Dali::Actor *)jarg2;
60580   if (!arg2) {
60581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60582     return ;
60583   }
60584   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60585   {
60586     try {
60587       (darg)->OnChildRemove(*arg2);
60588     } catch (std::out_of_range& e) {
60589       {
60590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60591       };
60592     } catch (std::exception& e) {
60593       {
60594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60595       };
60596     } catch (...) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60599       };
60600     }
60601   }
60602 }
60603
60604
60605 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60607   Dali::Actor *arg2 = 0 ;
60608   SwigDirector_ViewImpl *darg = 0;
60609
60610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60611   arg2 = (Dali::Actor *)jarg2;
60612   if (!arg2) {
60613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60614     return ;
60615   }
60616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60617   {
60618     try {
60619       (darg)->OnChildRemoveSwigPublic(*arg2);
60620     } catch (std::out_of_range& e) {
60621       {
60622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60623       };
60624     } catch (std::exception& e) {
60625       {
60626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60627       };
60628     } catch (...) {
60629       {
60630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60631       };
60632     }
60633   }
60634 }
60635
60636
60637 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60639   Dali::Property::Index arg2 ;
60640   Dali::Property::Value arg3 ;
60641   Dali::Property::Value *argp3 ;
60642   SwigDirector_ViewImpl *darg = 0;
60643
60644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60645   arg2 = (Dali::Property::Index)jarg2;
60646   argp3 = (Dali::Property::Value *)jarg3;
60647   if (!argp3) {
60648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60649     return ;
60650   }
60651   arg3 = *argp3;
60652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60653   {
60654     try {
60655       (darg)->OnPropertySet(arg2,arg3);
60656     } catch (std::out_of_range& e) {
60657       {
60658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60659       };
60660     } catch (std::exception& e) {
60661       {
60662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60667       };
60668     }
60669   }
60670 }
60671
60672
60673 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60675   Dali::Property::Index arg2 ;
60676   Dali::Property::Value arg3 ;
60677   Dali::Property::Value *argp3 ;
60678   SwigDirector_ViewImpl *darg = 0;
60679
60680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60681   arg2 = (Dali::Property::Index)jarg2;
60682   argp3 = (Dali::Property::Value *)jarg3;
60683   if (!argp3) {
60684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60685     return ;
60686   }
60687   arg3 = *argp3;
60688   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60689   {
60690     try {
60691       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60692     } catch (std::out_of_range& e) {
60693       {
60694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60695       };
60696     } catch (std::exception& e) {
60697       {
60698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60699       };
60700     } catch (...) {
60701       {
60702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60703       };
60704     }
60705   }
60706 }
60707
60708
60709 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60711   Dali::Vector3 *arg2 = 0 ;
60712   SwigDirector_ViewImpl *darg = 0;
60713
60714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60715   arg2 = (Dali::Vector3 *)jarg2;
60716   if (!arg2) {
60717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60718     return ;
60719   }
60720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60721   {
60722     try {
60723       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60724     } catch (std::out_of_range& e) {
60725       {
60726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60727       };
60728     } catch (std::exception& e) {
60729       {
60730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60731       };
60732     } catch (...) {
60733       {
60734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60735       };
60736     }
60737   }
60738 }
60739
60740
60741 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60743   Dali::Vector3 *arg2 = 0 ;
60744   SwigDirector_ViewImpl *darg = 0;
60745
60746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60747   arg2 = (Dali::Vector3 *)jarg2;
60748   if (!arg2) {
60749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60750     return ;
60751   }
60752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60753   {
60754     try {
60755       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60756     } catch (std::out_of_range& e) {
60757       {
60758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60759       };
60760     } catch (std::exception& e) {
60761       {
60762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60763       };
60764     } catch (...) {
60765       {
60766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60767       };
60768     }
60769   }
60770 }
60771
60772
60773 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60775   Dali::Animation *arg2 = 0 ;
60776   Dali::Vector3 *arg3 = 0 ;
60777   SwigDirector_ViewImpl *darg = 0;
60778
60779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60780   arg2 = (Dali::Animation *)jarg2;
60781   if (!arg2) {
60782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60783     return ;
60784   }
60785   arg3 = (Dali::Vector3 *)jarg3;
60786   if (!arg3) {
60787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60788     return ;
60789   }
60790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60791   {
60792     try {
60793       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60794     } catch (std::out_of_range& e) {
60795       {
60796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60797       };
60798     } catch (std::exception& e) {
60799       {
60800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60801       };
60802     } catch (...) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60805       };
60806     }
60807   }
60808 }
60809
60810
60811 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60813   Dali::Animation *arg2 = 0 ;
60814   Dali::Vector3 *arg3 = 0 ;
60815   SwigDirector_ViewImpl *darg = 0;
60816
60817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60818   arg2 = (Dali::Animation *)jarg2;
60819   if (!arg2) {
60820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60821     return ;
60822   }
60823   arg3 = (Dali::Vector3 *)jarg3;
60824   if (!arg3) {
60825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60826     return ;
60827   }
60828   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60829   {
60830     try {
60831       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60832     } catch (std::out_of_range& e) {
60833       {
60834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60835       };
60836     } catch (std::exception& e) {
60837       {
60838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60839       };
60840     } catch (...) {
60841       {
60842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60843       };
60844     }
60845   }
60846 }
60847
60848
60849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60850   unsigned int jresult ;
60851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60852   Dali::TouchEvent *arg2 = 0 ;
60853   SwigDirector_ViewImpl *darg = 0;
60854   bool result;
60855
60856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60857   arg2 = (Dali::TouchEvent *)jarg2;
60858   if (!arg2) {
60859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60860     return 0;
60861   }
60862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60863   {
60864     try {
60865       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60866     } catch (std::out_of_range& e) {
60867       {
60868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60869       };
60870     } catch (std::exception& e) {
60871       {
60872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60873       };
60874     } catch (...) {
60875       {
60876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60877       };
60878     }
60879   }
60880   jresult = result;
60881   return jresult;
60882 }
60883
60884
60885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60886   unsigned int jresult ;
60887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60888   Dali::TouchEvent *arg2 = 0 ;
60889   SwigDirector_ViewImpl *darg = 0;
60890   bool result;
60891
60892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60893   arg2 = (Dali::TouchEvent *)jarg2;
60894   if (!arg2) {
60895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60896     return 0;
60897   }
60898   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60899   {
60900     try {
60901       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60902     } catch (std::out_of_range& e) {
60903       {
60904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60905       };
60906     } catch (std::exception& e) {
60907       {
60908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60909       };
60910     } catch (...) {
60911       {
60912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60913       };
60914     }
60915   }
60916   jresult = result;
60917   return jresult;
60918 }
60919
60920
60921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60922   unsigned int jresult ;
60923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60924   Dali::HoverEvent *arg2 = 0 ;
60925   SwigDirector_ViewImpl *darg = 0;
60926   bool result;
60927
60928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60929   arg2 = (Dali::HoverEvent *)jarg2;
60930   if (!arg2) {
60931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60932     return 0;
60933   }
60934   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60935   {
60936     try {
60937       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60938     } catch (std::out_of_range& e) {
60939       {
60940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60941       };
60942     } catch (std::exception& e) {
60943       {
60944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60945       };
60946     } catch (...) {
60947       {
60948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60949       };
60950     }
60951   }
60952   jresult = result;
60953   return jresult;
60954 }
60955
60956
60957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60958   unsigned int jresult ;
60959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60960   Dali::HoverEvent *arg2 = 0 ;
60961   SwigDirector_ViewImpl *darg = 0;
60962   bool result;
60963
60964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60965   arg2 = (Dali::HoverEvent *)jarg2;
60966   if (!arg2) {
60967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60968     return 0;
60969   }
60970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60971   {
60972     try {
60973       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60974     } catch (std::out_of_range& e) {
60975       {
60976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60977       };
60978     } catch (std::exception& e) {
60979       {
60980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (...) {
60983       {
60984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60985       };
60986     }
60987   }
60988   jresult = result;
60989   return jresult;
60990 }
60991
60992
60993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60994   unsigned int jresult ;
60995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60996   Dali::KeyEvent *arg2 = 0 ;
60997   SwigDirector_ViewImpl *darg = 0;
60998   bool result;
60999
61000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61001   arg2 = (Dali::KeyEvent *)jarg2;
61002   if (!arg2) {
61003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61004     return 0;
61005   }
61006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61007   {
61008     try {
61009       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61010     } catch (std::out_of_range& e) {
61011       {
61012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61013       };
61014     } catch (std::exception& e) {
61015       {
61016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (...) {
61019       {
61020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61021       };
61022     }
61023   }
61024   jresult = result;
61025   return jresult;
61026 }
61027
61028
61029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61030   unsigned int jresult ;
61031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61032   Dali::KeyEvent *arg2 = 0 ;
61033   SwigDirector_ViewImpl *darg = 0;
61034   bool result;
61035
61036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61037   arg2 = (Dali::KeyEvent *)jarg2;
61038   if (!arg2) {
61039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61040     return 0;
61041   }
61042   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61043   {
61044     try {
61045       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61046     } catch (std::out_of_range& e) {
61047       {
61048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61049       };
61050     } catch (std::exception& e) {
61051       {
61052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61053       };
61054     } catch (...) {
61055       {
61056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61057       };
61058     }
61059   }
61060   jresult = result;
61061   return jresult;
61062 }
61063
61064
61065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61066   unsigned int jresult ;
61067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61068   Dali::WheelEvent *arg2 = 0 ;
61069   SwigDirector_ViewImpl *darg = 0;
61070   bool result;
61071
61072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61073   arg2 = (Dali::WheelEvent *)jarg2;
61074   if (!arg2) {
61075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61076     return 0;
61077   }
61078   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61079   {
61080     try {
61081       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096   jresult = result;
61097   return jresult;
61098 }
61099
61100
61101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61102   unsigned int jresult ;
61103   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61104   Dali::WheelEvent *arg2 = 0 ;
61105   SwigDirector_ViewImpl *darg = 0;
61106   bool result;
61107
61108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61109   arg2 = (Dali::WheelEvent *)jarg2;
61110   if (!arg2) {
61111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61112     return 0;
61113   }
61114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61115   {
61116     try {
61117       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61118     } catch (std::out_of_range& e) {
61119       {
61120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61121       };
61122     } catch (std::exception& e) {
61123       {
61124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61125       };
61126     } catch (...) {
61127       {
61128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61129       };
61130     }
61131   }
61132   jresult = result;
61133   return jresult;
61134 }
61135
61136
61137 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61139   Dali::Vector2 *arg2 = 0 ;
61140   Dali::RelayoutContainer *arg3 = 0 ;
61141   SwigDirector_ViewImpl *darg = 0;
61142
61143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61144   arg2 = (Dali::Vector2 *)jarg2;
61145   if (!arg2) {
61146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61147     return ;
61148   }
61149   arg3 = (Dali::RelayoutContainer *)jarg3;
61150   if (!arg3) {
61151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61152     return ;
61153   }
61154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61155   {
61156     try {
61157       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61158     } catch (std::out_of_range& e) {
61159       {
61160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61161       };
61162     } catch (std::exception& e) {
61163       {
61164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61165       };
61166     } catch (...) {
61167       {
61168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61169       };
61170     }
61171   }
61172 }
61173
61174
61175 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61177   Dali::Vector2 *arg2 = 0 ;
61178   Dali::RelayoutContainer *arg3 = 0 ;
61179   SwigDirector_ViewImpl *darg = 0;
61180
61181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61182   arg2 = (Dali::Vector2 *)jarg2;
61183   if (!arg2) {
61184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61185     return ;
61186   }
61187   arg3 = (Dali::RelayoutContainer *)jarg3;
61188   if (!arg3) {
61189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61190     return ;
61191   }
61192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61193   {
61194     try {
61195       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61203       };
61204     } catch (...) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61207       };
61208     }
61209   }
61210 }
61211
61212
61213 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61215   Dali::ResizePolicy::Type arg2 ;
61216   Dali::Dimension::Type arg3 ;
61217   SwigDirector_ViewImpl *darg = 0;
61218
61219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61220   arg2 = (Dali::ResizePolicy::Type)jarg2;
61221   arg3 = (Dali::Dimension::Type)jarg3;
61222   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61223   {
61224     try {
61225       (darg)->OnSetResizePolicy(arg2,arg3);
61226     } catch (std::out_of_range& e) {
61227       {
61228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61229       };
61230     } catch (std::exception& e) {
61231       {
61232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61233       };
61234     } catch (...) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61237       };
61238     }
61239   }
61240 }
61241
61242
61243 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61245   Dali::ResizePolicy::Type arg2 ;
61246   Dali::Dimension::Type arg3 ;
61247   SwigDirector_ViewImpl *darg = 0;
61248
61249   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61250   arg2 = (Dali::ResizePolicy::Type)jarg2;
61251   arg3 = (Dali::Dimension::Type)jarg3;
61252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61253   {
61254     try {
61255       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61256     } catch (std::out_of_range& e) {
61257       {
61258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61259       };
61260     } catch (std::exception& e) {
61261       {
61262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61263       };
61264     } catch (...) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61267       };
61268     }
61269   }
61270 }
61271
61272
61273 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNaturalSize(void * jarg1) {
61274   void * jresult ;
61275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61276   SwigDirector_ViewImpl *darg = 0;
61277   Dali::Vector3 result;
61278
61279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61280   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61281   {
61282     try {
61283       result = (darg)->GetNaturalSize();
61284     } catch (std::out_of_range& e) {
61285       {
61286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (std::exception& e) {
61289       {
61290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61291       };
61292     } catch (...) {
61293       {
61294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61295       };
61296     }
61297   }
61298   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61299   return jresult;
61300 }
61301
61302
61303 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61304   void * jresult ;
61305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61306   SwigDirector_ViewImpl *darg = 0;
61307   Dali::Vector3 result;
61308
61309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61310   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61311   {
61312     try {
61313       result = (darg)->GetNaturalSizeSwigPublic();
61314     } catch (std::out_of_range& e) {
61315       {
61316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61317       };
61318     } catch (std::exception& e) {
61319       {
61320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61325       };
61326     }
61327   }
61328   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61329   return jresult;
61330 }
61331
61332
61333 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61334   float jresult ;
61335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61336   Dali::Actor *arg2 = 0 ;
61337   Dali::Dimension::Type arg3 ;
61338   SwigDirector_ViewImpl *darg = 0;
61339   float result;
61340
61341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61342   arg2 = (Dali::Actor *)jarg2;
61343   if (!arg2) {
61344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61345     return 0;
61346   }
61347   arg3 = (Dali::Dimension::Type)jarg3;
61348   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61349   {
61350     try {
61351       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61352     } catch (std::out_of_range& e) {
61353       {
61354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (std::exception& e) {
61357       {
61358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61363       };
61364     }
61365   }
61366   jresult = result;
61367   return jresult;
61368 }
61369
61370
61371 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61372   float jresult ;
61373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61374   Dali::Actor *arg2 = 0 ;
61375   Dali::Dimension::Type arg3 ;
61376   SwigDirector_ViewImpl *darg = 0;
61377   float result;
61378
61379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61380   arg2 = (Dali::Actor *)jarg2;
61381   if (!arg2) {
61382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61383     return 0;
61384   }
61385   arg3 = (Dali::Dimension::Type)jarg3;
61386   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61387   {
61388     try {
61389       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61390     } catch (std::out_of_range& e) {
61391       {
61392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61393       };
61394     } catch (std::exception& e) {
61395       {
61396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61397       };
61398     } catch (...) {
61399       {
61400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61401       };
61402     }
61403   }
61404   jresult = result;
61405   return jresult;
61406 }
61407
61408
61409 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61410   float jresult ;
61411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61412   float arg2 ;
61413   SwigDirector_ViewImpl *darg = 0;
61414   float result;
61415
61416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61417   arg2 = (float)jarg2;
61418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61419   {
61420     try {
61421       result = (float)(darg)->GetHeightForWidth(arg2);
61422     } catch (std::out_of_range& e) {
61423       {
61424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (std::exception& e) {
61427       {
61428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61429       };
61430     } catch (...) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61433       };
61434     }
61435   }
61436   jresult = result;
61437   return jresult;
61438 }
61439
61440
61441 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61442   float jresult ;
61443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61444   float arg2 ;
61445   SwigDirector_ViewImpl *darg = 0;
61446   float result;
61447
61448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61449   arg2 = (float)jarg2;
61450   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61451   {
61452     try {
61453       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61454     } catch (std::out_of_range& e) {
61455       {
61456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (std::exception& e) {
61459       {
61460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (...) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61465       };
61466     }
61467   }
61468   jresult = result;
61469   return jresult;
61470 }
61471
61472
61473 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61474   float jresult ;
61475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61476   float arg2 ;
61477   SwigDirector_ViewImpl *darg = 0;
61478   float result;
61479
61480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61481   arg2 = (float)jarg2;
61482   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61483   {
61484     try {
61485       result = (float)(darg)->GetWidthForHeight(arg2);
61486     } catch (std::out_of_range& e) {
61487       {
61488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (std::exception& e) {
61491       {
61492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61493       };
61494     } catch (...) {
61495       {
61496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61497       };
61498     }
61499   }
61500   jresult = result;
61501   return jresult;
61502 }
61503
61504
61505 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61506   float jresult ;
61507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61508   float arg2 ;
61509   SwigDirector_ViewImpl *darg = 0;
61510   float result;
61511
61512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61513   arg2 = (float)jarg2;
61514   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61515   {
61516     try {
61517       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61518     } catch (std::out_of_range& e) {
61519       {
61520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61521       };
61522     } catch (std::exception& e) {
61523       {
61524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61525       };
61526     } catch (...) {
61527       {
61528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61529       };
61530     }
61531   }
61532   jresult = result;
61533   return jresult;
61534 }
61535
61536
61537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61538   unsigned int jresult ;
61539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61540   Dali::Dimension::Type arg2 ;
61541   SwigDirector_ViewImpl *darg = 0;
61542   bool result;
61543
61544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61545   arg2 = (Dali::Dimension::Type)jarg2;
61546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61547   {
61548     try {
61549       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61557       };
61558     } catch (...) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61561       };
61562     }
61563   }
61564   jresult = result;
61565   return jresult;
61566 }
61567
61568
61569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61570   unsigned int jresult ;
61571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61572   Dali::Dimension::Type arg2 ;
61573   SwigDirector_ViewImpl *darg = 0;
61574   bool result;
61575
61576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61577   arg2 = (Dali::Dimension::Type)jarg2;
61578   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61579   {
61580     try {
61581       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61582     } catch (std::out_of_range& e) {
61583       {
61584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61585       };
61586     } catch (std::exception& e) {
61587       {
61588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61589       };
61590     } catch (...) {
61591       {
61592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61593       };
61594     }
61595   }
61596   jresult = result;
61597   return jresult;
61598 }
61599
61600
61601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61602   unsigned int jresult ;
61603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61604   SwigDirector_ViewImpl *darg = 0;
61605   bool result;
61606
61607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61608   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61609   {
61610     try {
61611       result = (bool)(darg)->RelayoutDependentOnChildren();
61612     } catch (std::out_of_range& e) {
61613       {
61614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61615       };
61616     } catch (std::exception& e) {
61617       {
61618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61619       };
61620     } catch (...) {
61621       {
61622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61623       };
61624     }
61625   }
61626   jresult = result;
61627   return jresult;
61628 }
61629
61630
61631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61632   unsigned int jresult ;
61633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61634   SwigDirector_ViewImpl *darg = 0;
61635   bool result;
61636
61637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61639   {
61640     try {
61641       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61642     } catch (std::out_of_range& e) {
61643       {
61644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61645       };
61646     } catch (std::exception& e) {
61647       {
61648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61649       };
61650     } catch (...) {
61651       {
61652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61653       };
61654     }
61655   }
61656   jresult = result;
61657   return jresult;
61658 }
61659
61660
61661 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61663   Dali::Dimension::Type arg2 ;
61664   SwigDirector_ViewImpl *darg = 0;
61665
61666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61667   arg2 = (Dali::Dimension::Type)jarg2;
61668   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61669   {
61670     try {
61671       (darg)->OnCalculateRelayoutSize(arg2);
61672     } catch (std::out_of_range& e) {
61673       {
61674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61675       };
61676     } catch (std::exception& e) {
61677       {
61678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61679       };
61680     } catch (...) {
61681       {
61682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61683       };
61684     }
61685   }
61686 }
61687
61688
61689 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61691   Dali::Dimension::Type arg2 ;
61692   SwigDirector_ViewImpl *darg = 0;
61693
61694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61695   arg2 = (Dali::Dimension::Type)jarg2;
61696   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61697   {
61698     try {
61699       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61700     } catch (std::out_of_range& e) {
61701       {
61702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61703       };
61704     } catch (std::exception& e) {
61705       {
61706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61707       };
61708     } catch (...) {
61709       {
61710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61711       };
61712     }
61713   }
61714 }
61715
61716
61717 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61719   float arg2 ;
61720   Dali::Dimension::Type arg3 ;
61721   SwigDirector_ViewImpl *darg = 0;
61722
61723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61724   arg2 = (float)jarg2;
61725   arg3 = (Dali::Dimension::Type)jarg3;
61726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61727   {
61728     try {
61729       (darg)->OnLayoutNegotiated(arg2,arg3);
61730     } catch (std::out_of_range& e) {
61731       {
61732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61733       };
61734     } catch (std::exception& e) {
61735       {
61736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61737       };
61738     } catch (...) {
61739       {
61740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61741       };
61742     }
61743   }
61744 }
61745
61746
61747 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61749   float arg2 ;
61750   Dali::Dimension::Type arg3 ;
61751   SwigDirector_ViewImpl *darg = 0;
61752
61753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61754   arg2 = (float)jarg2;
61755   arg3 = (Dali::Dimension::Type)jarg3;
61756   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61757   {
61758     try {
61759       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61760     } catch (std::out_of_range& e) {
61761       {
61762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61763       };
61764     } catch (std::exception& e) {
61765       {
61766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61771       };
61772     }
61773   }
61774 }
61775
61776
61777 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnInitialize(void * jarg1) {
61778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61779
61780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61781   {
61782     try {
61783       (arg1)->OnInitialize();
61784     } catch (std::out_of_range& e) {
61785       {
61786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61787       };
61788     } catch (std::exception& e) {
61789       {
61790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61791       };
61792     } catch (...) {
61793       {
61794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61795       };
61796     }
61797   }
61798 }
61799
61800
61801 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61803
61804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61805   {
61806     try {
61807       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61808     } catch (std::out_of_range& e) {
61809       {
61810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61811       };
61812     } catch (std::exception& e) {
61813       {
61814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61815       };
61816     } catch (...) {
61817       {
61818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61819       };
61820     }
61821   }
61822 }
61823
61824
61825 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61827   Dali::Actor *arg2 = 0 ;
61828
61829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61830   arg2 = (Dali::Actor *)jarg2;
61831   if (!arg2) {
61832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61833     return ;
61834   }
61835   {
61836     try {
61837       (arg1)->OnControlChildAdd(*arg2);
61838     } catch (std::out_of_range& e) {
61839       {
61840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61841       };
61842     } catch (std::exception& e) {
61843       {
61844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61845       };
61846     } catch (...) {
61847       {
61848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61849       };
61850     }
61851   }
61852 }
61853
61854
61855 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61857   Dali::Actor *arg2 = 0 ;
61858
61859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61860   arg2 = (Dali::Actor *)jarg2;
61861   if (!arg2) {
61862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61863     return ;
61864   }
61865   {
61866     try {
61867       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61868     } catch (std::out_of_range& e) {
61869       {
61870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61871       };
61872     } catch (std::exception& e) {
61873       {
61874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61875       };
61876     } catch (...) {
61877       {
61878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61879       };
61880     }
61881   }
61882 }
61883
61884
61885 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61887   Dali::Actor *arg2 = 0 ;
61888
61889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61890   arg2 = (Dali::Actor *)jarg2;
61891   if (!arg2) {
61892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61893     return ;
61894   }
61895   {
61896     try {
61897       (arg1)->OnControlChildRemove(*arg2);
61898     } catch (std::out_of_range& e) {
61899       {
61900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61901       };
61902     } catch (std::exception& e) {
61903       {
61904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61905       };
61906     } catch (...) {
61907       {
61908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61909       };
61910     }
61911   }
61912 }
61913
61914
61915 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61917   Dali::Actor *arg2 = 0 ;
61918
61919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61920   arg2 = (Dali::Actor *)jarg2;
61921   if (!arg2) {
61922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61923     return ;
61924   }
61925   {
61926     try {
61927       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61928     } catch (std::out_of_range& e) {
61929       {
61930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61931       };
61932     } catch (std::exception& e) {
61933       {
61934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61935       };
61936     } catch (...) {
61937       {
61938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61939       };
61940     }
61941   }
61942 }
61943
61944
61945 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61947   Dali::Toolkit::StyleManager arg2 ;
61948   Dali::StyleChange::Type arg3 ;
61949   Dali::Toolkit::StyleManager *argp2 ;
61950
61951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61952   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61953   if (!argp2) {
61954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61955     return ;
61956   }
61957   arg2 = *argp2;
61958   arg3 = (Dali::StyleChange::Type)jarg3;
61959   {
61960     try {
61961       (arg1)->OnStyleChange(arg2,arg3);
61962     } catch (std::out_of_range& e) {
61963       {
61964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61965       };
61966     } catch (std::exception& e) {
61967       {
61968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61969       };
61970     } catch (...) {
61971       {
61972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61973       };
61974     }
61975   }
61976 }
61977
61978
61979 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61981   Dali::Toolkit::StyleManager arg2 ;
61982   Dali::StyleChange::Type arg3 ;
61983   Dali::Toolkit::StyleManager *argp2 ;
61984
61985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61986   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61987   if (!argp2) {
61988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61989     return ;
61990   }
61991   arg2 = *argp2;
61992   arg3 = (Dali::StyleChange::Type)jarg3;
61993   {
61994     try {
61995       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61996     } catch (std::out_of_range& e) {
61997       {
61998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61999       };
62000     } catch (std::exception& e) {
62001       {
62002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62003       };
62004     } catch (...) {
62005       {
62006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62007       };
62008     }
62009   }
62010 }
62011
62012
62013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62014   unsigned int jresult ;
62015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62016   bool result;
62017
62018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62019   {
62020     try {
62021       result = (bool)(arg1)->OnAccessibilityActivated();
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62029       };
62030     } catch (...) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62033       };
62034     }
62035   }
62036   jresult = result;
62037   return jresult;
62038 }
62039
62040
62041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62042   unsigned int jresult ;
62043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62044   bool result;
62045
62046   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62047   {
62048     try {
62049       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62050     } catch (std::out_of_range& e) {
62051       {
62052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62053       };
62054     } catch (std::exception& e) {
62055       {
62056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62057       };
62058     } catch (...) {
62059       {
62060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62061       };
62062     }
62063   }
62064   jresult = result;
62065   return jresult;
62066 }
62067
62068
62069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62070   unsigned int jresult ;
62071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62072   Dali::PanGesture arg2 ;
62073   Dali::PanGesture *argp2 ;
62074   bool result;
62075
62076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62077   argp2 = (Dali::PanGesture *)jarg2;
62078   if (!argp2) {
62079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62080     return 0;
62081   }
62082   arg2 = *argp2;
62083   {
62084     try {
62085       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62086     } catch (std::out_of_range& e) {
62087       {
62088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62089       };
62090     } catch (std::exception& e) {
62091       {
62092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (...) {
62095       {
62096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62097       };
62098     }
62099   }
62100   jresult = result;
62101   return jresult;
62102 }
62103
62104
62105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62106   unsigned int jresult ;
62107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62108   Dali::PanGesture arg2 ;
62109   Dali::PanGesture *argp2 ;
62110   bool result;
62111
62112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62113   argp2 = (Dali::PanGesture *)jarg2;
62114   if (!argp2) {
62115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62116     return 0;
62117   }
62118   arg2 = *argp2;
62119   {
62120     try {
62121       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62122     } catch (std::out_of_range& e) {
62123       {
62124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62125       };
62126     } catch (std::exception& e) {
62127       {
62128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62129       };
62130     } catch (...) {
62131       {
62132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62133       };
62134     }
62135   }
62136   jresult = result;
62137   return jresult;
62138 }
62139
62140
62141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62142   unsigned int jresult ;
62143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62144   Dali::TouchEvent *arg2 = 0 ;
62145   bool result;
62146
62147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62148   arg2 = (Dali::TouchEvent *)jarg2;
62149   if (!arg2) {
62150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62151     return 0;
62152   }
62153   {
62154     try {
62155       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62156     } catch (std::out_of_range& e) {
62157       {
62158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62159       };
62160     } catch (std::exception& e) {
62161       {
62162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62163       };
62164     } catch (...) {
62165       {
62166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62167       };
62168     }
62169   }
62170   jresult = result;
62171   return jresult;
62172 }
62173
62174
62175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62176   unsigned int jresult ;
62177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62178   Dali::TouchEvent *arg2 = 0 ;
62179   bool result;
62180
62181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62182   arg2 = (Dali::TouchEvent *)jarg2;
62183   if (!arg2) {
62184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62185     return 0;
62186   }
62187   {
62188     try {
62189       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62190     } catch (std::out_of_range& e) {
62191       {
62192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62193       };
62194     } catch (std::exception& e) {
62195       {
62196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62197       };
62198     } catch (...) {
62199       {
62200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62201       };
62202     }
62203   }
62204   jresult = result;
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62210   unsigned int jresult ;
62211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62212   bool arg2 ;
62213   bool result;
62214
62215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62216   arg2 = jarg2 ? true : false;
62217   {
62218     try {
62219       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62220     } catch (std::out_of_range& e) {
62221       {
62222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (std::exception& e) {
62225       {
62226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234   jresult = result;
62235   return jresult;
62236 }
62237
62238
62239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62240   unsigned int jresult ;
62241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62242   bool arg2 ;
62243   bool result;
62244
62245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62246   arg2 = jarg2 ? true : false;
62247   {
62248     try {
62249       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62250     } catch (std::out_of_range& e) {
62251       {
62252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62253       };
62254     } catch (std::exception& e) {
62255       {
62256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62257       };
62258     } catch (...) {
62259       {
62260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62261       };
62262     }
62263   }
62264   jresult = result;
62265   return jresult;
62266 }
62267
62268
62269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62270   unsigned int jresult ;
62271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62272   bool result;
62273
62274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62275   {
62276     try {
62277       result = (bool)(arg1)->OnAccessibilityZoom();
62278     } catch (std::out_of_range& e) {
62279       {
62280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62281       };
62282     } catch (std::exception& e) {
62283       {
62284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62285       };
62286     } catch (...) {
62287       {
62288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62289       };
62290     }
62291   }
62292   jresult = result;
62293   return jresult;
62294 }
62295
62296
62297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62298   unsigned int jresult ;
62299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62300   bool result;
62301
62302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62303   {
62304     try {
62305       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62306     } catch (std::out_of_range& e) {
62307       {
62308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62309       };
62310     } catch (std::exception& e) {
62311       {
62312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62313       };
62314     } catch (...) {
62315       {
62316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62317       };
62318     }
62319   }
62320   jresult = result;
62321   return jresult;
62322 }
62323
62324
62325 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62327
62328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62329   {
62330     try {
62331       (arg1)->OnKeyInputFocusGained();
62332     } catch (std::out_of_range& e) {
62333       {
62334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62335       };
62336     } catch (std::exception& e) {
62337       {
62338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62339       };
62340     } catch (...) {
62341       {
62342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62343       };
62344     }
62345   }
62346 }
62347
62348
62349 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62351
62352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62353   {
62354     try {
62355       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62356     } catch (std::out_of_range& e) {
62357       {
62358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62359       };
62360     } catch (std::exception& e) {
62361       {
62362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62363       };
62364     } catch (...) {
62365       {
62366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62367       };
62368     }
62369   }
62370 }
62371
62372
62373 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62375
62376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62377   {
62378     try {
62379       (arg1)->OnKeyInputFocusLost();
62380     } catch (std::out_of_range& e) {
62381       {
62382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62383       };
62384     } catch (std::exception& e) {
62385       {
62386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62387       };
62388     } catch (...) {
62389       {
62390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62391       };
62392     }
62393   }
62394 }
62395
62396
62397 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62399
62400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62401   {
62402     try {
62403       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62404     } catch (std::out_of_range& e) {
62405       {
62406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62407       };
62408     } catch (std::exception& e) {
62409       {
62410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62411       };
62412     } catch (...) {
62413       {
62414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62415       };
62416     }
62417   }
62418 }
62419
62420
62421 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62422   void * jresult ;
62423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62424   Dali::Actor arg2 ;
62425   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62426   bool arg4 ;
62427   Dali::Actor *argp2 ;
62428   Dali::Actor result;
62429
62430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62431   argp2 = (Dali::Actor *)jarg2;
62432   if (!argp2) {
62433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62434     return 0;
62435   }
62436   arg2 = *argp2;
62437   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62438   arg4 = jarg4 ? true : false;
62439   {
62440     try {
62441       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62442     } catch (std::out_of_range& e) {
62443       {
62444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62445       };
62446     } catch (std::exception& e) {
62447       {
62448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62449       };
62450     } catch (...) {
62451       {
62452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62453       };
62454     }
62455   }
62456   jresult = new Dali::Actor((const Dali::Actor &)result);
62457   return jresult;
62458 }
62459
62460
62461 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62462   void * jresult ;
62463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62464   Dali::Actor arg2 ;
62465   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62466   bool arg4 ;
62467   Dali::Actor *argp2 ;
62468   Dali::Actor result;
62469
62470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62471   argp2 = (Dali::Actor *)jarg2;
62472   if (!argp2) {
62473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62474     return 0;
62475   }
62476   arg2 = *argp2;
62477   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62478   arg4 = jarg4 ? true : false;
62479   {
62480     try {
62481       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62482     } catch (std::out_of_range& e) {
62483       {
62484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62485       };
62486     } catch (std::exception& e) {
62487       {
62488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (...) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62493       };
62494     }
62495   }
62496   jresult = new Dali::Actor((const Dali::Actor &)result);
62497   return jresult;
62498 }
62499
62500
62501 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62503   Dali::Actor arg2 ;
62504   Dali::Actor *argp2 ;
62505
62506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62507   argp2 = (Dali::Actor *)jarg2;
62508   if (!argp2) {
62509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62510     return ;
62511   }
62512   arg2 = *argp2;
62513   {
62514     try {
62515       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62516     } catch (std::out_of_range& e) {
62517       {
62518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62519       };
62520     } catch (std::exception& e) {
62521       {
62522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62523       };
62524     } catch (...) {
62525       {
62526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62527       };
62528     }
62529   }
62530 }
62531
62532
62533 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   Dali::Actor arg2 ;
62536   Dali::Actor *argp2 ;
62537
62538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62539   argp2 = (Dali::Actor *)jarg2;
62540   if (!argp2) {
62541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62542     return ;
62543   }
62544   arg2 = *argp2;
62545   {
62546     try {
62547       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62548     } catch (std::out_of_range& e) {
62549       {
62550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62551       };
62552     } catch (std::exception& e) {
62553       {
62554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62555       };
62556     } catch (...) {
62557       {
62558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62559       };
62560     }
62561   }
62562 }
62563
62564
62565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardEnter(void * jarg1) {
62566   unsigned int jresult ;
62567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62568   bool result;
62569
62570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62571   {
62572     try {
62573       result = (bool)(arg1)->OnKeyboardEnter();
62574     } catch (std::out_of_range& e) {
62575       {
62576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (std::exception& e) {
62579       {
62580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62581       };
62582     } catch (...) {
62583       {
62584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62585       };
62586     }
62587   }
62588   jresult = result;
62589   return jresult;
62590 }
62591
62592
62593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62594   unsigned int jresult ;
62595   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62596   bool result;
62597
62598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62599   {
62600     try {
62601       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62602     } catch (std::out_of_range& e) {
62603       {
62604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62605       };
62606     } catch (std::exception& e) {
62607       {
62608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (...) {
62611       {
62612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62613       };
62614     }
62615   }
62616   jresult = result;
62617   return jresult;
62618 }
62619
62620
62621 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62623   Dali::PinchGesture *arg2 = 0 ;
62624
62625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62626   arg2 = (Dali::PinchGesture *)jarg2;
62627   if (!arg2) {
62628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62629     return ;
62630   }
62631   {
62632     try {
62633       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62634     } catch (std::out_of_range& e) {
62635       {
62636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62637       };
62638     } catch (std::exception& e) {
62639       {
62640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62641       };
62642     } catch (...) {
62643       {
62644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62645       };
62646     }
62647   }
62648 }
62649
62650
62651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62653   Dali::PinchGesture *arg2 = 0 ;
62654
62655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62656   arg2 = (Dali::PinchGesture *)jarg2;
62657   if (!arg2) {
62658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62659     return ;
62660   }
62661   {
62662     try {
62663       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62664     } catch (std::out_of_range& e) {
62665       {
62666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62667       };
62668     } catch (std::exception& e) {
62669       {
62670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62671       };
62672     } catch (...) {
62673       {
62674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62675       };
62676     }
62677   }
62678 }
62679
62680
62681 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62683   Dali::PanGesture *arg2 = 0 ;
62684
62685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62686   arg2 = (Dali::PanGesture *)jarg2;
62687   if (!arg2) {
62688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62689     return ;
62690   }
62691   {
62692     try {
62693       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62694     } catch (std::out_of_range& e) {
62695       {
62696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62697       };
62698     } catch (std::exception& e) {
62699       {
62700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62701       };
62702     } catch (...) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62705       };
62706     }
62707   }
62708 }
62709
62710
62711 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62713   Dali::PanGesture *arg2 = 0 ;
62714
62715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62716   arg2 = (Dali::PanGesture *)jarg2;
62717   if (!arg2) {
62718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62719     return ;
62720   }
62721   {
62722     try {
62723       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62724     } catch (std::out_of_range& e) {
62725       {
62726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62727       };
62728     } catch (std::exception& e) {
62729       {
62730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62731       };
62732     } catch (...) {
62733       {
62734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62735       };
62736     }
62737   }
62738 }
62739
62740
62741 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62743   Dali::TapGesture *arg2 = 0 ;
62744
62745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62746   arg2 = (Dali::TapGesture *)jarg2;
62747   if (!arg2) {
62748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62749     return ;
62750   }
62751   {
62752     try {
62753       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62754     } catch (std::out_of_range& e) {
62755       {
62756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62757       };
62758     } catch (std::exception& e) {
62759       {
62760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62761       };
62762     } catch (...) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62765       };
62766     }
62767   }
62768 }
62769
62770
62771 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62773   Dali::TapGesture *arg2 = 0 ;
62774
62775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62776   arg2 = (Dali::TapGesture *)jarg2;
62777   if (!arg2) {
62778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62779     return ;
62780   }
62781   {
62782     try {
62783       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62795       };
62796     }
62797   }
62798 }
62799
62800
62801 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62803   Dali::LongPressGesture *arg2 = 0 ;
62804
62805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62806   arg2 = (Dali::LongPressGesture *)jarg2;
62807   if (!arg2) {
62808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62809     return ;
62810   }
62811   {
62812     try {
62813       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62814     } catch (std::out_of_range& e) {
62815       {
62816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62817       };
62818     } catch (std::exception& e) {
62819       {
62820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62821       };
62822     } catch (...) {
62823       {
62824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62825       };
62826     }
62827   }
62828 }
62829
62830
62831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62833   Dali::LongPressGesture *arg2 = 0 ;
62834
62835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62836   arg2 = (Dali::LongPressGesture *)jarg2;
62837   if (!arg2) {
62838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62839     return ;
62840   }
62841   {
62842     try {
62843       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62844     } catch (std::out_of_range& e) {
62845       {
62846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62847       };
62848     } catch (std::exception& e) {
62849       {
62850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62851       };
62852     } catch (...) {
62853       {
62854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62855       };
62856     }
62857   }
62858 }
62859
62860
62861 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62863   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62864   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62865
62866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62867   arg2 = (Dali::SlotObserver *)jarg2;
62868   arg3 = (Dali::CallbackBase *)jarg3;
62869   {
62870     try {
62871       (arg1)->SignalConnected(arg2,arg3);
62872     } catch (std::out_of_range& e) {
62873       {
62874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62875       };
62876     } catch (std::exception& e) {
62877       {
62878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62879       };
62880     } catch (...) {
62881       {
62882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62883       };
62884     }
62885   }
62886 }
62887
62888
62889 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62891   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62892   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62893
62894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62895   arg2 = (Dali::SlotObserver *)jarg2;
62896   arg3 = (Dali::CallbackBase *)jarg3;
62897   {
62898     try {
62899       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62900     } catch (std::out_of_range& e) {
62901       {
62902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62903       };
62904     } catch (std::exception& e) {
62905       {
62906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62907       };
62908     } catch (...) {
62909       {
62910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62911       };
62912     }
62913   }
62914 }
62915
62916
62917 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62919   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62920   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62921
62922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62923   arg2 = (Dali::SlotObserver *)jarg2;
62924   arg3 = (Dali::CallbackBase *)jarg3;
62925   {
62926     try {
62927       (arg1)->SignalDisconnected(arg2,arg3);
62928     } catch (std::out_of_range& e) {
62929       {
62930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62931       };
62932     } catch (std::exception& e) {
62933       {
62934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62935       };
62936     } catch (...) {
62937       {
62938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62939       };
62940     }
62941   }
62942 }
62943
62944
62945 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62947   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62948   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62949
62950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62951   arg2 = (Dali::SlotObserver *)jarg2;
62952   arg3 = (Dali::CallbackBase *)jarg3;
62953   {
62954     try {
62955       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62956     } catch (std::out_of_range& e) {
62957       {
62958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62959       };
62960     } catch (std::exception& e) {
62961       {
62962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62963       };
62964     } catch (...) {
62965       {
62966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62967       };
62968     }
62969   }
62970 }
62971
62972
62973 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_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) {
62974   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62975   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62976   if (director) {
62977     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);
62978   }
62979 }
62980
62981
62982 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GetImplementation__SWIG_0(void * jarg1) {
62983   void * jresult ;
62984   Dali::Toolkit::Control *arg1 = 0 ;
62985   Dali::Toolkit::Internal::Control *result = 0 ;
62986
62987   arg1 = (Dali::Toolkit::Control *)jarg1;
62988   if (!arg1) {
62989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62990     return 0;
62991   }
62992   {
62993     try {
62994       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62995     } catch (std::out_of_range& e) {
62996       {
62997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62998       };
62999     } catch (std::exception& e) {
63000       {
63001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (...) {
63004       {
63005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63006       };
63007     }
63008   }
63009   jresult = (void *)result;
63010   return jresult;
63011 }
63012
63013
63014 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_STYLE_NAME_get() {
63015   int jresult ;
63016   int result;
63017
63018   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63019   jresult = (int)result;
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_COLOR_get() {
63025   int jresult ;
63026   int result;
63027
63028   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63029   jresult = (int)result;
63030   return jresult;
63031 }
63032
63033
63034 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_IMAGE_get() {
63035   int jresult ;
63036   int result;
63037
63038   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63039   jresult = (int)result;
63040   return jresult;
63041 }
63042
63043
63044 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_KEY_INPUT_FOCUS_get() {
63045   int jresult ;
63046   int result;
63047
63048   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63049   jresult = (int)result;
63050   return jresult;
63051 }
63052
63053
63054 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_get() {
63055   int jresult ;
63056   int result;
63057
63058   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63059   jresult = (int)result;
63060   return jresult;
63061 }
63062
63063
63064 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View_Property() {
63065   void * jresult ;
63066   Dali::Toolkit::Control::Property *result = 0 ;
63067
63068   {
63069     try {
63070       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63071     } catch (std::out_of_range& e) {
63072       {
63073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63074       };
63075     } catch (std::exception& e) {
63076       {
63077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63082       };
63083     }
63084   }
63085   jresult = (void *)result;
63086   return jresult;
63087 }
63088
63089
63090 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View_Property(void * jarg1) {
63091   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63092
63093   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63094   {
63095     try {
63096       delete arg1;
63097     } catch (std::out_of_range& e) {
63098       {
63099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63100       };
63101     } catch (std::exception& e) {
63102       {
63103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63108       };
63109     }
63110   }
63111 }
63112
63113
63114 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View_KeyboardFocus() {
63115   void * jresult ;
63116   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63117
63118   {
63119     try {
63120       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63121     } catch (std::out_of_range& e) {
63122       {
63123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63124       };
63125     } catch (std::exception& e) {
63126       {
63127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63128       };
63129     } catch (...) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63132       };
63133     }
63134   }
63135   jresult = (void *)result;
63136   return jresult;
63137 }
63138
63139
63140 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View_KeyboardFocus(void * jarg1) {
63141   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63142
63143   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63144   {
63145     try {
63146       delete arg1;
63147     } catch (std::out_of_range& e) {
63148       {
63149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63150       };
63151     } catch (std::exception& e) {
63152       {
63153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63154       };
63155     } catch (...) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63158       };
63159     }
63160   }
63161 }
63162
63163
63164 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_New() {
63165   void * jresult ;
63166   Dali::Toolkit::Control result;
63167
63168   {
63169     try {
63170       result = Dali::Toolkit::Control::New();
63171     } catch (std::out_of_range& e) {
63172       {
63173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63174       };
63175     } catch (std::exception& e) {
63176       {
63177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63178       };
63179     } catch (...) {
63180       {
63181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63182       };
63183     }
63184   }
63185   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63186   return jresult;
63187 }
63188
63189
63190 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_0() {
63191   void * jresult ;
63192   Dali::Toolkit::Control *result = 0 ;
63193
63194   {
63195     try {
63196       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63197     } catch (std::out_of_range& e) {
63198       {
63199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63200       };
63201     } catch (std::exception& e) {
63202       {
63203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63204       };
63205     } catch (...) {
63206       {
63207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63208       };
63209     }
63210   }
63211   jresult = (void *)result;
63212   return jresult;
63213 }
63214
63215
63216 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_1(void * jarg1) {
63217   void * jresult ;
63218   Dali::Toolkit::Control *arg1 = 0 ;
63219   Dali::Toolkit::Control *result = 0 ;
63220
63221   arg1 = (Dali::Toolkit::Control *)jarg1;
63222   if (!arg1) {
63223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63224     return 0;
63225   }
63226   {
63227     try {
63228       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63229     } catch (std::out_of_range& e) {
63230       {
63231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63232       };
63233     } catch (std::exception& e) {
63234       {
63235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63236       };
63237     } catch (...) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63240       };
63241     }
63242   }
63243   jresult = (void *)result;
63244   return jresult;
63245 }
63246
63247
63248 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View(void * jarg1) {
63249   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63250
63251   arg1 = (Dali::Toolkit::Control *)jarg1;
63252   {
63253     try {
63254       delete arg1;
63255     } catch (std::out_of_range& e) {
63256       {
63257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63258       };
63259     } catch (std::exception& e) {
63260       {
63261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63262       };
63263     } catch (...) {
63264       {
63265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63266       };
63267     }
63268   }
63269 }
63270
63271
63272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_Assign(void * jarg1, void * jarg2) {
63273   void * jresult ;
63274   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63275   Dali::Toolkit::Control *arg2 = 0 ;
63276   Dali::Toolkit::Control *result = 0 ;
63277
63278   arg1 = (Dali::Toolkit::Control *)jarg1;
63279   arg2 = (Dali::Toolkit::Control *)jarg2;
63280   if (!arg2) {
63281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63282     return 0;
63283   }
63284   {
63285     try {
63286       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (...) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63298       };
63299     }
63300   }
63301   jresult = (void *)result;
63302   return jresult;
63303 }
63304
63305
63306 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_DownCast(void * jarg1) {
63307   void * jresult ;
63308   Dali::BaseHandle arg1 ;
63309   Dali::BaseHandle *argp1 ;
63310   Dali::Toolkit::Control result;
63311
63312   argp1 = (Dali::BaseHandle *)jarg1;
63313   if (!argp1) {
63314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63315     return 0;
63316   }
63317   arg1 = *argp1;
63318   {
63319     try {
63320       result = Dali::Toolkit::Control::DownCast(arg1);
63321     } catch (std::out_of_range& e) {
63322       {
63323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63324       };
63325     } catch (std::exception& e) {
63326       {
63327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63328       };
63329     } catch (...) {
63330       {
63331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63332       };
63333     }
63334   }
63335   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63336   return jresult;
63337 }
63338
63339
63340 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetKeyInputFocus(void * jarg1) {
63341   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63342
63343   arg1 = (Dali::Toolkit::Control *)jarg1;
63344   {
63345     try {
63346       (arg1)->SetKeyInputFocus();
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63354       };
63355     } catch (...) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63358       };
63359     }
63360   }
63361 }
63362
63363
63364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_View_HasKeyInputFocus(void * jarg1) {
63365   unsigned int jresult ;
63366   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63367   bool result;
63368
63369   arg1 = (Dali::Toolkit::Control *)jarg1;
63370   {
63371     try {
63372       result = (bool)(arg1)->HasKeyInputFocus();
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (...) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63384       };
63385     }
63386   }
63387   jresult = result;
63388   return jresult;
63389 }
63390
63391
63392 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_ClearKeyInputFocus(void * jarg1) {
63393   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63394
63395   arg1 = (Dali::Toolkit::Control *)jarg1;
63396   {
63397     try {
63398       (arg1)->ClearKeyInputFocus();
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63406       };
63407     } catch (...) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63410       };
63411     }
63412   }
63413 }
63414
63415
63416 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetPinchGestureDetector(void * jarg1) {
63417   void * jresult ;
63418   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63419   Dali::PinchGestureDetector result;
63420
63421   arg1 = (Dali::Toolkit::Control *)jarg1;
63422   {
63423     try {
63424       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63425     } catch (std::out_of_range& e) {
63426       {
63427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63428       };
63429     } catch (std::exception& e) {
63430       {
63431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63432       };
63433     } catch (...) {
63434       {
63435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63436       };
63437     }
63438   }
63439   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63440   return jresult;
63441 }
63442
63443
63444 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetPanGestureDetector(void * jarg1) {
63445   void * jresult ;
63446   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63447   Dali::PanGestureDetector result;
63448
63449   arg1 = (Dali::Toolkit::Control *)jarg1;
63450   {
63451     try {
63452       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63453     } catch (std::out_of_range& e) {
63454       {
63455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63456       };
63457     } catch (std::exception& e) {
63458       {
63459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63460       };
63461     } catch (...) {
63462       {
63463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63464       };
63465     }
63466   }
63467   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63468   return jresult;
63469 }
63470
63471
63472 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetTapGestureDetector(void * jarg1) {
63473   void * jresult ;
63474   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63475   Dali::TapGestureDetector result;
63476
63477   arg1 = (Dali::Toolkit::Control *)jarg1;
63478   {
63479     try {
63480       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63481     } catch (std::out_of_range& e) {
63482       {
63483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63484       };
63485     } catch (std::exception& e) {
63486       {
63487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63488       };
63489     } catch (...) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63492       };
63493     }
63494   }
63495   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63496   return jresult;
63497 }
63498
63499
63500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetLongPressGestureDetector(void * jarg1) {
63501   void * jresult ;
63502   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63503   Dali::LongPressGestureDetector result;
63504
63505   arg1 = (Dali::Toolkit::Control *)jarg1;
63506   {
63507     try {
63508       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63509     } catch (std::out_of_range& e) {
63510       {
63511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63512       };
63513     } catch (std::exception& e) {
63514       {
63515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63520       };
63521     }
63522   }
63523   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetStyleName(void * jarg1, char * jarg2) {
63529   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63530   std::string *arg2 = 0 ;
63531
63532   arg1 = (Dali::Toolkit::Control *)jarg1;
63533   if (!jarg2) {
63534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63535     return ;
63536   }
63537   std::string arg2_str(jarg2);
63538   arg2 = &arg2_str;
63539   {
63540     try {
63541       (arg1)->SetStyleName((std::string const &)*arg2);
63542     } catch (std::out_of_range& e) {
63543       {
63544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (std::exception& e) {
63547       {
63548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63553       };
63554     }
63555   }
63556
63557   //argout typemap for const std::string&
63558
63559 }
63560
63561
63562 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_View_GetStyleName(void * jarg1) {
63563   char * jresult ;
63564   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63565   std::string *result = 0 ;
63566
63567   arg1 = (Dali::Toolkit::Control *)jarg1;
63568   {
63569     try {
63570       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585   jresult = SWIG_csharp_string_callback(result->c_str());
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63592   Dali::Vector4 *arg2 = 0 ;
63593
63594   arg1 = (Dali::Toolkit::Control *)jarg1;
63595   arg2 = (Dali::Vector4 *)jarg2;
63596   if (!arg2) {
63597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63598     return ;
63599   }
63600   {
63601     try {
63602       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63603     } catch (std::out_of_range& e) {
63604       {
63605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63606       };
63607     } catch (std::exception& e) {
63608       {
63609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63610       };
63611     } catch (...) {
63612       {
63613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63614       };
63615     }
63616   }
63617 }
63618
63619
63620 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetBackgroundColor(void * jarg1) {
63621   void * jresult ;
63622   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63623   Dali::Vector4 result;
63624
63625   arg1 = (Dali::Toolkit::Control *)jarg1;
63626   {
63627     try {
63628       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63629     } catch (std::out_of_range& e) {
63630       {
63631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63632       };
63633     } catch (std::exception& e) {
63634       {
63635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63640       };
63641     }
63642   }
63643   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63644   return jresult;
63645 }
63646
63647
63648 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63649   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63650   Dali::Image arg2 ;
63651   Dali::Image *argp2 ;
63652
63653   arg1 = (Dali::Toolkit::Control *)jarg1;
63654   argp2 = (Dali::Image *)jarg2;
63655   if (!argp2) {
63656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63657     return ;
63658   }
63659   arg2 = *argp2;
63660   {
63661     try {
63662       (arg1)->SetBackgroundImage(arg2);
63663     } catch (std::out_of_range& e) {
63664       {
63665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63666       };
63667     } catch (std::exception& e) {
63668       {
63669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63670       };
63671     } catch (...) {
63672       {
63673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63674       };
63675     }
63676   }
63677 }
63678
63679
63680 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_ClearBackground(void * jarg1) {
63681   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63682
63683   arg1 = (Dali::Toolkit::Control *)jarg1;
63684   {
63685     try {
63686       (arg1)->ClearBackground();
63687     } catch (std::out_of_range& e) {
63688       {
63689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63690       };
63691     } catch (std::exception& e) {
63692       {
63693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63694       };
63695     } catch (...) {
63696       {
63697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63698       };
63699     }
63700   }
63701 }
63702
63703
63704 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyEventSignal(void * jarg1) {
63705   void * jresult ;
63706   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63707   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63708
63709   arg1 = (Dali::Toolkit::Control *)jarg1;
63710   {
63711     try {
63712       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63713     } catch (std::out_of_range& e) {
63714       {
63715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63716       };
63717     } catch (std::exception& e) {
63718       {
63719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63720       };
63721     } catch (...) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63724       };
63725     }
63726   }
63727   jresult = (void *)result;
63728   return jresult;
63729 }
63730
63731
63732 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyInputFocusGainedSignal(void * jarg1) {
63733   void * jresult ;
63734   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63735   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63736
63737   arg1 = (Dali::Toolkit::Control *)jarg1;
63738   {
63739     try {
63740       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63741     } catch (std::out_of_range& e) {
63742       {
63743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (std::exception& e) {
63746       {
63747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63752       };
63753     }
63754   }
63755   jresult = (void *)result;
63756   return jresult;
63757 }
63758
63759
63760 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyInputFocusLostSignal(void * jarg1) {
63761   void * jresult ;
63762   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63763   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63764
63765   arg1 = (Dali::Toolkit::Control *)jarg1;
63766   {
63767     try {
63768       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63769     } catch (std::out_of_range& e) {
63770       {
63771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63772       };
63773     } catch (std::exception& e) {
63774       {
63775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63776       };
63777     } catch (...) {
63778       {
63779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63780       };
63781     }
63782   }
63783   jresult = (void *)result;
63784   return jresult;
63785 }
63786
63787
63788 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_2(void * jarg1) {
63789   void * jresult ;
63790   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63791   Dali::Toolkit::Control *result = 0 ;
63792
63793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63794   if (!arg1) {
63795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63796     return 0;
63797   }
63798   {
63799     try {
63800       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (...) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63812       };
63813     }
63814   }
63815   jresult = (void *)result;
63816   return jresult;
63817 }
63818
63819
63820 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyInputFocusManager() {
63821   void * jresult ;
63822   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63823
63824   {
63825     try {
63826       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63827     } catch (std::out_of_range& e) {
63828       {
63829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63830       };
63831     } catch (std::exception& e) {
63832       {
63833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63834       };
63835     } catch (...) {
63836       {
63837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63838       };
63839     }
63840   }
63841   jresult = (void *)result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyInputFocusManager(void * jarg1) {
63847   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63848
63849   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63850   {
63851     try {
63852       delete arg1;
63853     } catch (std::out_of_range& e) {
63854       {
63855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63856       };
63857     } catch (std::exception& e) {
63858       {
63859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63860       };
63861     } catch (...) {
63862       {
63863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63864       };
63865     }
63866   }
63867 }
63868
63869
63870 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_Get() {
63871   void * jresult ;
63872   Dali::Toolkit::KeyInputFocusManager result;
63873
63874   {
63875     try {
63876       result = Dali::Toolkit::KeyInputFocusManager::Get();
63877     } catch (std::out_of_range& e) {
63878       {
63879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63880       };
63881     } catch (std::exception& e) {
63882       {
63883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63884       };
63885     } catch (...) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63888       };
63889     }
63890   }
63891   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63892   return jresult;
63893 }
63894
63895
63896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63897   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63898   Dali::Toolkit::Control arg2 ;
63899   Dali::Toolkit::Control *argp2 ;
63900
63901   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63902   argp2 = (Dali::Toolkit::Control *)jarg2;
63903   if (!argp2) {
63904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63905     return ;
63906   }
63907   arg2 = *argp2;
63908   {
63909     try {
63910       (arg1)->SetFocus(arg2);
63911     } catch (std::out_of_range& e) {
63912       {
63913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63914       };
63915     } catch (std::exception& e) {
63916       {
63917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63918       };
63919     } catch (...) {
63920       {
63921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63922       };
63923     }
63924   }
63925 }
63926
63927
63928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63929   void * jresult ;
63930   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63931   Dali::Toolkit::Control result;
63932
63933   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63934   {
63935     try {
63936       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63937     } catch (std::out_of_range& e) {
63938       {
63939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63940       };
63941     } catch (std::exception& e) {
63942       {
63943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63944       };
63945     } catch (...) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63948       };
63949     }
63950   }
63951   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63952   return jresult;
63953 }
63954
63955
63956 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63957   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63958   Dali::Toolkit::Control arg2 ;
63959   Dali::Toolkit::Control *argp2 ;
63960
63961   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63962   argp2 = (Dali::Toolkit::Control *)jarg2;
63963   if (!argp2) {
63964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63965     return ;
63966   }
63967   arg2 = *argp2;
63968   {
63969     try {
63970       (arg1)->RemoveFocus(arg2);
63971     } catch (std::out_of_range& e) {
63972       {
63973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63974       };
63975     } catch (std::exception& e) {
63976       {
63977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63978       };
63979     } catch (...) {
63980       {
63981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63982       };
63983     }
63984   }
63985 }
63986
63987
63988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
63989   unsigned int jresult ;
63990   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63991   Dali::Toolkit::Control arg2 ;
63992   Dali::Toolkit::Control *argp2 ;
63993   bool result;
63994
63995   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63996   argp2 = (Dali::Toolkit::Control *)jarg2;
63997   if (!argp2) {
63998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63999     return 0;
64000   }
64001   arg2 = *argp2;
64002   {
64003     try {
64004       result = (bool)(arg1)->IsKeyboardListener(arg2);
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019   jresult = result;
64020   return jresult;
64021 }
64022
64023
64024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64025   void * jresult ;
64026   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64027   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64028
64029   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64030   {
64031     try {
64032       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64033     } catch (std::out_of_range& e) {
64034       {
64035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64036       };
64037     } catch (std::exception& e) {
64038       {
64039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64040       };
64041     } catch (...) {
64042       {
64043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64044       };
64045     }
64046   }
64047   jresult = (void *)result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
64053   void * jresult ;
64054   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64055   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
64056
64057   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64058   {
64059     try {
64060       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
64061     } catch (std::out_of_range& e) {
64062       {
64063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64064       };
64065     } catch (std::exception& e) {
64066       {
64067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64068       };
64069     } catch (...) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64072       };
64073     }
64074   }
64075   jresult = (void *)result;
64076   return jresult;
64077 }
64078
64079
64080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment_Padding__SWIG_0() {
64081   void * jresult ;
64082   Dali::Toolkit::Alignment::Padding *result = 0 ;
64083
64084   {
64085     try {
64086       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64087     } catch (std::out_of_range& e) {
64088       {
64089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64090       };
64091     } catch (std::exception& e) {
64092       {
64093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64094       };
64095     } catch (...) {
64096       {
64097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64098       };
64099     }
64100   }
64101   jresult = (void *)result;
64102   return jresult;
64103 }
64104
64105
64106 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64107   void * jresult ;
64108   float arg1 ;
64109   float arg2 ;
64110   float arg3 ;
64111   float arg4 ;
64112   Dali::Toolkit::Alignment::Padding *result = 0 ;
64113
64114   arg1 = (float)jarg1;
64115   arg2 = (float)jarg2;
64116   arg3 = (float)jarg3;
64117   arg4 = (float)jarg4;
64118   {
64119     try {
64120       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64121     } catch (std::out_of_range& e) {
64122       {
64123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64124       };
64125     } catch (std::exception& e) {
64126       {
64127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64128       };
64129     } catch (...) {
64130       {
64131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64132       };
64133     }
64134   }
64135   jresult = (void *)result;
64136   return jresult;
64137 }
64138
64139
64140 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64141   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64142   float arg2 ;
64143
64144   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64145   arg2 = (float)jarg2;
64146   if (arg1) (arg1)->left = arg2;
64147 }
64148
64149
64150 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_left_get(void * jarg1) {
64151   float jresult ;
64152   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64153   float result;
64154
64155   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64156   result = (float) ((arg1)->left);
64157   jresult = result;
64158   return jresult;
64159 }
64160
64161
64162 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64163   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64164   float arg2 ;
64165
64166   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64167   arg2 = (float)jarg2;
64168   if (arg1) (arg1)->right = arg2;
64169 }
64170
64171
64172 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_right_get(void * jarg1) {
64173   float jresult ;
64174   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64175   float result;
64176
64177   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64178   result = (float) ((arg1)->right);
64179   jresult = result;
64180   return jresult;
64181 }
64182
64183
64184 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64185   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64186   float arg2 ;
64187
64188   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64189   arg2 = (float)jarg2;
64190   if (arg1) (arg1)->top = arg2;
64191 }
64192
64193
64194 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_top_get(void * jarg1) {
64195   float jresult ;
64196   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64197   float result;
64198
64199   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64200   result = (float) ((arg1)->top);
64201   jresult = result;
64202   return jresult;
64203 }
64204
64205
64206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64207   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64208   float arg2 ;
64209
64210   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64211   arg2 = (float)jarg2;
64212   if (arg1) (arg1)->bottom = arg2;
64213 }
64214
64215
64216 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_bottom_get(void * jarg1) {
64217   float jresult ;
64218   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64219   float result;
64220
64221   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64222   result = (float) ((arg1)->bottom);
64223   jresult = result;
64224   return jresult;
64225 }
64226
64227
64228 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Alignment_Padding(void * jarg1) {
64229   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64230
64231   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64232   {
64233     try {
64234       delete arg1;
64235     } catch (std::out_of_range& e) {
64236       {
64237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64238       };
64239     } catch (std::exception& e) {
64240       {
64241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64242       };
64243     } catch (...) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64246       };
64247     }
64248   }
64249 }
64250
64251
64252 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment__SWIG_0() {
64253   void * jresult ;
64254   Dali::Toolkit::Alignment *result = 0 ;
64255
64256   {
64257     try {
64258       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64259     } catch (std::out_of_range& e) {
64260       {
64261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64262       };
64263     } catch (std::exception& e) {
64264       {
64265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64266       };
64267     } catch (...) {
64268       {
64269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64270       };
64271     }
64272   }
64273   jresult = (void *)result;
64274   return jresult;
64275 }
64276
64277
64278 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64279   void * jresult ;
64280   Dali::Toolkit::Alignment::Type arg1 ;
64281   Dali::Toolkit::Alignment::Type arg2 ;
64282   Dali::Toolkit::Alignment result;
64283
64284   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64285   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64286   {
64287     try {
64288       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64289     } catch (std::out_of_range& e) {
64290       {
64291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64292       };
64293     } catch (std::exception& e) {
64294       {
64295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64296       };
64297     } catch (...) {
64298       {
64299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64300       };
64301     }
64302   }
64303   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64304   return jresult;
64305 }
64306
64307
64308 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_1(int jarg1) {
64309   void * jresult ;
64310   Dali::Toolkit::Alignment::Type arg1 ;
64311   Dali::Toolkit::Alignment result;
64312
64313   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64314   {
64315     try {
64316       result = Dali::Toolkit::Alignment::New(arg1);
64317     } catch (std::out_of_range& e) {
64318       {
64319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (std::exception& e) {
64322       {
64323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64328       };
64329     }
64330   }
64331   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64332   return jresult;
64333 }
64334
64335
64336 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_2() {
64337   void * jresult ;
64338   Dali::Toolkit::Alignment result;
64339
64340   {
64341     try {
64342       result = Dali::Toolkit::Alignment::New();
64343     } catch (std::out_of_range& e) {
64344       {
64345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64346       };
64347     } catch (std::exception& e) {
64348       {
64349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64354       };
64355     }
64356   }
64357   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64358   return jresult;
64359 }
64360
64361
64362 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment__SWIG_1(void * jarg1) {
64363   void * jresult ;
64364   Dali::Toolkit::Alignment *arg1 = 0 ;
64365   Dali::Toolkit::Alignment *result = 0 ;
64366
64367   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64368   if (!arg1) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64370     return 0;
64371   }
64372   {
64373     try {
64374       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64382       };
64383     } catch (...) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64386       };
64387     }
64388   }
64389   jresult = (void *)result;
64390   return jresult;
64391 }
64392
64393
64394 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Alignment(void * jarg1) {
64395   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64396
64397   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64398   {
64399     try {
64400       delete arg1;
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64408       };
64409     } catch (...) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64412       };
64413     }
64414   }
64415 }
64416
64417
64418 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_DownCast(void * jarg1) {
64419   void * jresult ;
64420   Dali::BaseHandle arg1 ;
64421   Dali::BaseHandle *argp1 ;
64422   Dali::Toolkit::Alignment result;
64423
64424   argp1 = (Dali::BaseHandle *)jarg1;
64425   if (!argp1) {
64426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64427     return 0;
64428   }
64429   arg1 = *argp1;
64430   {
64431     try {
64432       result = Dali::Toolkit::Alignment::DownCast(arg1);
64433     } catch (std::out_of_range& e) {
64434       {
64435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64436       };
64437     } catch (std::exception& e) {
64438       {
64439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64440       };
64441     } catch (...) {
64442       {
64443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64444       };
64445     }
64446   }
64447   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64448   return jresult;
64449 }
64450
64451
64452 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64453   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64454   Dali::Toolkit::Alignment::Type arg2 ;
64455
64456   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64457   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64458   {
64459     try {
64460       (arg1)->SetAlignmentType(arg2);
64461     } catch (std::out_of_range& e) {
64462       {
64463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64464       };
64465     } catch (std::exception& e) {
64466       {
64467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64468       };
64469     } catch (...) {
64470       {
64471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64472       };
64473     }
64474   }
64475 }
64476
64477
64478 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Alignment_GetAlignmentType(void * jarg1) {
64479   int jresult ;
64480   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64481   Dali::Toolkit::Alignment::Type result;
64482
64483   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64484   {
64485     try {
64486       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64487     } catch (std::out_of_range& e) {
64488       {
64489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64490       };
64491     } catch (std::exception& e) {
64492       {
64493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64494       };
64495     } catch (...) {
64496       {
64497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64498       };
64499     }
64500   }
64501   jresult = (int)result;
64502   return jresult;
64503 }
64504
64505
64506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetScaling(void * jarg1, int jarg2) {
64507   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64508   Dali::Toolkit::Alignment::Scaling arg2 ;
64509
64510   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64511   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64512   {
64513     try {
64514       (arg1)->SetScaling(arg2);
64515     } catch (std::out_of_range& e) {
64516       {
64517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64518       };
64519     } catch (std::exception& e) {
64520       {
64521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64522       };
64523     } catch (...) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64526       };
64527     }
64528   }
64529 }
64530
64531
64532 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Alignment_GetScaling(void * jarg1) {
64533   int jresult ;
64534   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64535   Dali::Toolkit::Alignment::Scaling result;
64536
64537   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64538   {
64539     try {
64540       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64541     } catch (std::out_of_range& e) {
64542       {
64543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64544       };
64545     } catch (std::exception& e) {
64546       {
64547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64548       };
64549     } catch (...) {
64550       {
64551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64552       };
64553     }
64554   }
64555   jresult = (int)result;
64556   return jresult;
64557 }
64558
64559
64560 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetPadding(void * jarg1, void * jarg2) {
64561   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64562   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64563
64564   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64565   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64566   if (!arg2) {
64567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64568     return ;
64569   }
64570   {
64571     try {
64572       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64573     } catch (std::out_of_range& e) {
64574       {
64575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64576       };
64577     } catch (std::exception& e) {
64578       {
64579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64580       };
64581     } catch (...) {
64582       {
64583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64584       };
64585     }
64586   }
64587 }
64588
64589
64590 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_GetPadding(void * jarg1) {
64591   void * jresult ;
64592   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64593   Dali::Toolkit::Alignment::Padding *result = 0 ;
64594
64595   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64596   {
64597     try {
64598       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64599     } catch (std::out_of_range& e) {
64600       {
64601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64602       };
64603     } catch (std::exception& e) {
64604       {
64605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (...) {
64608       {
64609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64610       };
64611     }
64612   }
64613   jresult = (void *)result;
64614   return jresult;
64615 }
64616
64617
64618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_Assign(void * jarg1, void * jarg2) {
64619   void * jresult ;
64620   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64621   Dali::Toolkit::Alignment *arg2 = 0 ;
64622   Dali::Toolkit::Alignment *result = 0 ;
64623
64624   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64625   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64626   if (!arg2) {
64627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64628     return 0;
64629   }
64630   {
64631     try {
64632       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64633     } catch (std::out_of_range& e) {
64634       {
64635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64636       };
64637     } catch (std::exception& e) {
64638       {
64639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64640       };
64641     } catch (...) {
64642       {
64643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64644       };
64645     }
64646   }
64647   jresult = (void *)result;
64648   return jresult;
64649 }
64650
64651
64652 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_DISABLED_get() {
64653   int jresult ;
64654   int result;
64655
64656   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64657   jresult = (int)result;
64658   return jresult;
64659 }
64660
64661
64662 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_AUTO_REPEATING_get() {
64663   int jresult ;
64664   int result;
64665
64666   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64667   jresult = (int)result;
64668   return jresult;
64669 }
64670
64671
64672 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64673   int jresult ;
64674   int result;
64675
64676   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64677   jresult = (int)result;
64678   return jresult;
64679 }
64680
64681
64682 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64683   int jresult ;
64684   int result;
64685
64686   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64687   jresult = (int)result;
64688   return jresult;
64689 }
64690
64691
64692 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_TOGGLABLE_get() {
64693   int jresult ;
64694   int result;
64695
64696   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64697   jresult = (int)result;
64698   return jresult;
64699 }
64700
64701
64702 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_get() {
64703   int jresult ;
64704   int result;
64705
64706   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64707   jresult = (int)result;
64708   return jresult;
64709 }
64710
64711
64712 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_UNSELECTED_STATE_IMAGE_get() {
64713   int jresult ;
64714   int result;
64715
64716   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
64717   jresult = (int)result;
64718   return jresult;
64719 }
64720
64721
64722 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_STATE_IMAGE_get() {
64723   int jresult ;
64724   int result;
64725
64726   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
64727   jresult = (int)result;
64728   return jresult;
64729 }
64730
64731
64732 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_DISABLED_STATE_IMAGE_get() {
64733   int jresult ;
64734   int result;
64735
64736   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
64737   jresult = (int)result;
64738   return jresult;
64739 }
64740
64741
64742 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_UNSELECTED_COLOR_get() {
64743   int jresult ;
64744   int result;
64745
64746   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64747   jresult = (int)result;
64748   return jresult;
64749 }
64750
64751
64752 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_COLOR_get() {
64753   int jresult ;
64754   int result;
64755
64756   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64757   jresult = (int)result;
64758   return jresult;
64759 }
64760
64761
64762 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_LABEL_get() {
64763   int jresult ;
64764   int result;
64765
64766   result = (int)Dali::Toolkit::Button::Property::LABEL;
64767   jresult = (int)result;
64768   return jresult;
64769 }
64770
64771
64772 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_LABEL_TEXT_get() {
64773   int jresult ;
64774   int result;
64775
64776   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64777   jresult = (int)result;
64778   return jresult;
64779 }
64780
64781
64782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button_Property() {
64783   void * jresult ;
64784   Dali::Toolkit::Button::Property *result = 0 ;
64785
64786   {
64787     try {
64788       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64789     } catch (std::out_of_range& e) {
64790       {
64791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64792       };
64793     } catch (std::exception& e) {
64794       {
64795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64796       };
64797     } catch (...) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64800       };
64801     }
64802   }
64803   jresult = (void *)result;
64804   return jresult;
64805 }
64806
64807
64808 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Button_Property(void * jarg1) {
64809   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64810
64811   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64812   {
64813     try {
64814       delete arg1;
64815     } catch (std::out_of_range& e) {
64816       {
64817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64818       };
64819     } catch (std::exception& e) {
64820       {
64821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64822       };
64823     } catch (...) {
64824       {
64825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64826       };
64827     }
64828   }
64829 }
64830
64831
64832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button__SWIG_0() {
64833   void * jresult ;
64834   Dali::Toolkit::Button *result = 0 ;
64835
64836   {
64837     try {
64838       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64839     } catch (std::out_of_range& e) {
64840       {
64841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64842       };
64843     } catch (std::exception& e) {
64844       {
64845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64846       };
64847     } catch (...) {
64848       {
64849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64850       };
64851     }
64852   }
64853   jresult = (void *)result;
64854   return jresult;
64855 }
64856
64857
64858 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button__SWIG_1(void * jarg1) {
64859   void * jresult ;
64860   Dali::Toolkit::Button *arg1 = 0 ;
64861   Dali::Toolkit::Button *result = 0 ;
64862
64863   arg1 = (Dali::Toolkit::Button *)jarg1;
64864   if (!arg1) {
64865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64866     return 0;
64867   }
64868   {
64869     try {
64870       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64871     } catch (std::out_of_range& e) {
64872       {
64873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64874       };
64875     } catch (std::exception& e) {
64876       {
64877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64878       };
64879     } catch (...) {
64880       {
64881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64882       };
64883     }
64884   }
64885   jresult = (void *)result;
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_Assign(void * jarg1, void * jarg2) {
64891   void * jresult ;
64892   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64893   Dali::Toolkit::Button *arg2 = 0 ;
64894   Dali::Toolkit::Button *result = 0 ;
64895
64896   arg1 = (Dali::Toolkit::Button *)jarg1;
64897   arg2 = (Dali::Toolkit::Button *)jarg2;
64898   if (!arg2) {
64899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64900     return 0;
64901   }
64902   {
64903     try {
64904       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64905     } catch (std::out_of_range& e) {
64906       {
64907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64908       };
64909     } catch (std::exception& e) {
64910       {
64911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64912       };
64913     } catch (...) {
64914       {
64915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64916       };
64917     }
64918   }
64919   jresult = (void *)result;
64920   return jresult;
64921 }
64922
64923
64924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_DownCast(void * jarg1) {
64925   void * jresult ;
64926   Dali::BaseHandle arg1 ;
64927   Dali::BaseHandle *argp1 ;
64928   Dali::Toolkit::Button result;
64929
64930   argp1 = (Dali::BaseHandle *)jarg1;
64931   if (!argp1) {
64932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64933     return 0;
64934   }
64935   arg1 = *argp1;
64936   {
64937     try {
64938       result = Dali::Toolkit::Button::DownCast(arg1);
64939     } catch (std::out_of_range& e) {
64940       {
64941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64942       };
64943     } catch (std::exception& e) {
64944       {
64945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64946       };
64947     } catch (...) {
64948       {
64949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64950       };
64951     }
64952   }
64953   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64954   return jresult;
64955 }
64956
64957
64958 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Button(void * jarg1) {
64959   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64960
64961   arg1 = (Dali::Toolkit::Button *)jarg1;
64962   {
64963     try {
64964       delete arg1;
64965     } catch (std::out_of_range& e) {
64966       {
64967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64968       };
64969     } catch (std::exception& e) {
64970       {
64971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64972       };
64973     } catch (...) {
64974       {
64975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64976       };
64977     }
64978   }
64979 }
64980
64981
64982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsDisabled(void * jarg1) {
64983   unsigned int jresult ;
64984   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64985   bool result;
64986
64987   arg1 = (Dali::Toolkit::Button *)jarg1;
64988   {
64989     try {
64990       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64991     } catch (std::out_of_range& e) {
64992       {
64993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (std::exception& e) {
64996       {
64997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64998       };
64999     } catch (...) {
65000       {
65001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65002       };
65003     }
65004   }
65005   jresult = result;
65006   return jresult;
65007 }
65008
65009
65010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsAutoRepeating(void * jarg1) {
65011   unsigned int jresult ;
65012   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65013   bool result;
65014
65015   arg1 = (Dali::Toolkit::Button *)jarg1;
65016   {
65017     try {
65018       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65019     } catch (std::out_of_range& e) {
65020       {
65021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65022       };
65023     } catch (std::exception& e) {
65024       {
65025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65026       };
65027     } catch (...) {
65028       {
65029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65030       };
65031     }
65032   }
65033   jresult = result;
65034   return jresult;
65035 }
65036
65037
65038 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65039   float jresult ;
65040   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65041   float result;
65042
65043   arg1 = (Dali::Toolkit::Button *)jarg1;
65044   {
65045     try {
65046       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65047     } catch (std::out_of_range& e) {
65048       {
65049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65050       };
65051     } catch (std::exception& e) {
65052       {
65053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65054       };
65055     } catch (...) {
65056       {
65057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65058       };
65059     }
65060   }
65061   jresult = result;
65062   return jresult;
65063 }
65064
65065
65066 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65067   float jresult ;
65068   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65069   float result;
65070
65071   arg1 = (Dali::Toolkit::Button *)jarg1;
65072   {
65073     try {
65074       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65075     } catch (std::out_of_range& e) {
65076       {
65077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65078       };
65079     } catch (std::exception& e) {
65080       {
65081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65082       };
65083     } catch (...) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65086       };
65087     }
65088   }
65089   jresult = result;
65090   return jresult;
65091 }
65092
65093
65094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsTogglableButton(void * jarg1) {
65095   unsigned int jresult ;
65096   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65097   bool result;
65098
65099   arg1 = (Dali::Toolkit::Button *)jarg1;
65100   {
65101     try {
65102       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65103     } catch (std::out_of_range& e) {
65104       {
65105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65106       };
65107     } catch (std::exception& e) {
65108       {
65109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65110       };
65111     } catch (...) {
65112       {
65113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65114       };
65115     }
65116   }
65117   jresult = result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsSelected(void * jarg1) {
65123   unsigned int jresult ;
65124   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65125   bool result;
65126
65127   arg1 = (Dali::Toolkit::Button *)jarg1;
65128   {
65129     try {
65130       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65131     } catch (std::out_of_range& e) {
65132       {
65133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65134       };
65135     } catch (std::exception& e) {
65136       {
65137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (...) {
65140       {
65141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65142       };
65143     }
65144   }
65145   jresult = result;
65146   return jresult;
65147 }
65148
65149
65150 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetAnimationTime(void * jarg1) {
65151   float jresult ;
65152   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65153   float result;
65154
65155   arg1 = (Dali::Toolkit::Button *)jarg1;
65156   {
65157     try {
65158       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65159     } catch (std::out_of_range& e) {
65160       {
65161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (std::exception& e) {
65164       {
65165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65170       };
65171     }
65172   }
65173   jresult = result;
65174   return jresult;
65175 }
65176
65177
65178 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Button_GetLabelText(void * jarg1) {
65179   char * jresult ;
65180   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65181   std::string result;
65182
65183   arg1 = (Dali::Toolkit::Button *)jarg1;
65184   {
65185     try {
65186       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65187     } catch (std::out_of_range& e) {
65188       {
65189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65190       };
65191     } catch (std::exception& e) {
65192       {
65193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65194       };
65195     } catch (...) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65198       };
65199     }
65200   }
65201   jresult = SWIG_csharp_string_callback((&result)->c_str());
65202   return jresult;
65203 }
65204
65205
65206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetLabel(void * jarg1, void * jarg2) {
65207   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65208   Dali::Actor arg2 ;
65209   Dali::Actor *argp2 ;
65210
65211   arg1 = (Dali::Toolkit::Button *)jarg1;
65212   argp2 = (Dali::Actor *)jarg2;
65213   if (!argp2) {
65214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65215     return ;
65216   }
65217   arg2 = *argp2;
65218   {
65219     try {
65220       (arg1)->SetLabel(arg2);
65221     } catch (std::out_of_range& e) {
65222       {
65223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65224       };
65225     } catch (std::exception& e) {
65226       {
65227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65228       };
65229     } catch (...) {
65230       {
65231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65232       };
65233     }
65234   }
65235 }
65236
65237
65238 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetButtonImage(void * jarg1, void * jarg2) {
65239   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65240   Dali::Image arg2 ;
65241   Dali::Image *argp2 ;
65242
65243   arg1 = (Dali::Toolkit::Button *)jarg1;
65244   argp2 = (Dali::Image *)jarg2;
65245   if (!argp2) {
65246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65247     return ;
65248   }
65249   arg2 = *argp2;
65250   {
65251     try {
65252       (arg1)->SetButtonImage(arg2);
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65264       };
65265     }
65266   }
65267 }
65268
65269
65270 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65271   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65272   Dali::Image arg2 ;
65273   Dali::Image *argp2 ;
65274
65275   arg1 = (Dali::Toolkit::Button *)jarg1;
65276   argp2 = (Dali::Image *)jarg2;
65277   if (!argp2) {
65278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65279     return ;
65280   }
65281   arg2 = *argp2;
65282   {
65283     try {
65284       (arg1)->SetSelectedImage(arg2);
65285     } catch (std::out_of_range& e) {
65286       {
65287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65288       };
65289     } catch (std::exception& e) {
65290       {
65291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65292       };
65293     } catch (...) {
65294       {
65295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65296       };
65297     }
65298   }
65299 }
65300
65301
65302 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_GetButtonImage(void * jarg1) {
65303   void * jresult ;
65304   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65305   Dali::Actor result;
65306
65307   arg1 = (Dali::Toolkit::Button *)jarg1;
65308   {
65309     try {
65310       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65311     } catch (std::out_of_range& e) {
65312       {
65313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (std::exception& e) {
65316       {
65317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65318       };
65319     } catch (...) {
65320       {
65321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65322       };
65323     }
65324   }
65325   jresult = new Dali::Actor((const Dali::Actor &)result);
65326   return jresult;
65327 }
65328
65329
65330 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_GetSelectedImage(void * jarg1) {
65331   void * jresult ;
65332   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65333   Dali::Actor result;
65334
65335   arg1 = (Dali::Toolkit::Button *)jarg1;
65336   {
65337     try {
65338       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65339     } catch (std::out_of_range& e) {
65340       {
65341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (std::exception& e) {
65344       {
65345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65346       };
65347     } catch (...) {
65348       {
65349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65350       };
65351     }
65352   }
65353   jresult = new Dali::Actor((const Dali::Actor &)result);
65354   return jresult;
65355 }
65356
65357
65358 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_PressedSignal(void * jarg1) {
65359   void * jresult ;
65360   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65361   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65362
65363   arg1 = (Dali::Toolkit::Button *)jarg1;
65364   {
65365     try {
65366       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65367     } catch (std::out_of_range& e) {
65368       {
65369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65370       };
65371     } catch (std::exception& e) {
65372       {
65373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65374       };
65375     } catch (...) {
65376       {
65377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65378       };
65379     }
65380   }
65381   jresult = (void *)result;
65382   return jresult;
65383 }
65384
65385
65386 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_ReleasedSignal(void * jarg1) {
65387   void * jresult ;
65388   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65389   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65390
65391   arg1 = (Dali::Toolkit::Button *)jarg1;
65392   {
65393     try {
65394       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65395     } catch (std::out_of_range& e) {
65396       {
65397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65398       };
65399     } catch (std::exception& e) {
65400       {
65401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65402       };
65403     } catch (...) {
65404       {
65405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65406       };
65407     }
65408   }
65409   jresult = (void *)result;
65410   return jresult;
65411 }
65412
65413
65414 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_ClickedSignal(void * jarg1) {
65415   void * jresult ;
65416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65417   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65418
65419   arg1 = (Dali::Toolkit::Button *)jarg1;
65420   {
65421     try {
65422       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65423     } catch (std::out_of_range& e) {
65424       {
65425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (std::exception& e) {
65428       {
65429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65430       };
65431     } catch (...) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65434       };
65435     }
65436   }
65437   jresult = (void *)result;
65438   return jresult;
65439 }
65440
65441
65442 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_StateChangedSignal(void * jarg1) {
65443   void * jresult ;
65444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65445   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65446
65447   arg1 = (Dali::Toolkit::Button *)jarg1;
65448   {
65449     try {
65450       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65451     } catch (std::out_of_range& e) {
65452       {
65453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65454       };
65455     } catch (std::exception& e) {
65456       {
65457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65458       };
65459     } catch (...) {
65460       {
65461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65462       };
65463     }
65464   }
65465   jresult = (void *)result;
65466   return jresult;
65467 }
65468
65469
65470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CheckBoxButton__SWIG_0() {
65471   void * jresult ;
65472   Dali::Toolkit::CheckBoxButton *result = 0 ;
65473
65474   {
65475     try {
65476       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65477     } catch (std::out_of_range& e) {
65478       {
65479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65480       };
65481     } catch (std::exception& e) {
65482       {
65483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65484       };
65485     } catch (...) {
65486       {
65487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65488       };
65489     }
65490   }
65491   jresult = (void *)result;
65492   return jresult;
65493 }
65494
65495
65496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CheckBoxButton__SWIG_1(void * jarg1) {
65497   void * jresult ;
65498   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65499   Dali::Toolkit::CheckBoxButton *result = 0 ;
65500
65501   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65502   if (!arg1) {
65503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65504     return 0;
65505   }
65506   {
65507     try {
65508       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65509     } catch (std::out_of_range& e) {
65510       {
65511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65512       };
65513     } catch (std::exception& e) {
65514       {
65515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65516       };
65517     } catch (...) {
65518       {
65519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65520       };
65521     }
65522   }
65523   jresult = (void *)result;
65524   return jresult;
65525 }
65526
65527
65528 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65529   void * jresult ;
65530   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65531   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65532   Dali::Toolkit::CheckBoxButton *result = 0 ;
65533
65534   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65535   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65536   if (!arg2) {
65537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65538     return 0;
65539   }
65540   {
65541     try {
65542       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65543     } catch (std::out_of_range& e) {
65544       {
65545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65546       };
65547     } catch (std::exception& e) {
65548       {
65549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65550       };
65551     } catch (...) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65554       };
65555     }
65556   }
65557   jresult = (void *)result;
65558   return jresult;
65559 }
65560
65561
65562 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CheckBoxButton(void * jarg1) {
65563   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65564
65565   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65566   {
65567     try {
65568       delete arg1;
65569     } catch (std::out_of_range& e) {
65570       {
65571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65572       };
65573     } catch (std::exception& e) {
65574       {
65575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65576       };
65577     } catch (...) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65580       };
65581     }
65582   }
65583 }
65584
65585
65586 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_New() {
65587   void * jresult ;
65588   Dali::Toolkit::CheckBoxButton result;
65589
65590   {
65591     try {
65592       result = Dali::Toolkit::CheckBoxButton::New();
65593     } catch (std::out_of_range& e) {
65594       {
65595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65596       };
65597     } catch (std::exception& e) {
65598       {
65599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65600       };
65601     } catch (...) {
65602       {
65603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65604       };
65605     }
65606   }
65607   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65608   return jresult;
65609 }
65610
65611
65612 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_DownCast(void * jarg1) {
65613   void * jresult ;
65614   Dali::BaseHandle arg1 ;
65615   Dali::BaseHandle *argp1 ;
65616   Dali::Toolkit::CheckBoxButton result;
65617
65618   argp1 = (Dali::BaseHandle *)jarg1;
65619   if (!argp1) {
65620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65621     return 0;
65622   }
65623   arg1 = *argp1;
65624   {
65625     try {
65626       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65627     } catch (std::out_of_range& e) {
65628       {
65629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65630       };
65631     } catch (std::exception& e) {
65632       {
65633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65638       };
65639     }
65640   }
65641   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65642   return jresult;
65643 }
65644
65645
65646 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_UNSELECTED_ICON_get() {
65647   int jresult ;
65648   int result;
65649
65650   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65651   jresult = (int)result;
65652   return jresult;
65653 }
65654
65655
65656 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_SELECTED_ICON_get() {
65657   int jresult ;
65658   int result;
65659
65660   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65661   jresult = (int)result;
65662   return jresult;
65663 }
65664
65665
65666 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_ICON_ALIGNMENT_get() {
65667   int jresult ;
65668   int result;
65669
65670   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65671   jresult = (int)result;
65672   return jresult;
65673 }
65674
65675
65676 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_LABEL_PADDING_get() {
65677   int jresult ;
65678   int result;
65679
65680   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65681   jresult = (int)result;
65682   return jresult;
65683 }
65684
65685
65686 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_ICON_PADDING_get() {
65687   int jresult ;
65688   int result;
65689
65690   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65691   jresult = (int)result;
65692   return jresult;
65693 }
65694
65695
65696 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton_Property() {
65697   void * jresult ;
65698   Dali::Toolkit::PushButton::Property *result = 0 ;
65699
65700   {
65701     try {
65702       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (...) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65714       };
65715     }
65716   }
65717   jresult = (void *)result;
65718   return jresult;
65719 }
65720
65721
65722 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PushButton_Property(void * jarg1) {
65723   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65724
65725   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65726   {
65727     try {
65728       delete arg1;
65729     } catch (std::out_of_range& e) {
65730       {
65731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65732       };
65733     } catch (std::exception& e) {
65734       {
65735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65736       };
65737     } catch (...) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65740       };
65741     }
65742   }
65743 }
65744
65745
65746 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton__SWIG_0() {
65747   void * jresult ;
65748   Dali::Toolkit::PushButton *result = 0 ;
65749
65750   {
65751     try {
65752       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65753     } catch (std::out_of_range& e) {
65754       {
65755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65756       };
65757     } catch (std::exception& e) {
65758       {
65759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65760       };
65761     } catch (...) {
65762       {
65763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65764       };
65765     }
65766   }
65767   jresult = (void *)result;
65768   return jresult;
65769 }
65770
65771
65772 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton__SWIG_1(void * jarg1) {
65773   void * jresult ;
65774   Dali::Toolkit::PushButton *arg1 = 0 ;
65775   Dali::Toolkit::PushButton *result = 0 ;
65776
65777   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65778   if (!arg1) {
65779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65780     return 0;
65781   }
65782   {
65783     try {
65784       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65785     } catch (std::out_of_range& e) {
65786       {
65787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65788       };
65789     } catch (std::exception& e) {
65790       {
65791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65792       };
65793     } catch (...) {
65794       {
65795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65796       };
65797     }
65798   }
65799   jresult = (void *)result;
65800   return jresult;
65801 }
65802
65803
65804 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_Assign(void * jarg1, void * jarg2) {
65805   void * jresult ;
65806   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65807   Dali::Toolkit::PushButton *arg2 = 0 ;
65808   Dali::Toolkit::PushButton *result = 0 ;
65809
65810   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65811   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65812   if (!arg2) {
65813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65814     return 0;
65815   }
65816   {
65817     try {
65818       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65819     } catch (std::out_of_range& e) {
65820       {
65821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65822       };
65823     } catch (std::exception& e) {
65824       {
65825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65826       };
65827     } catch (...) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65830       };
65831     }
65832   }
65833   jresult = (void *)result;
65834   return jresult;
65835 }
65836
65837
65838 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PushButton(void * jarg1) {
65839   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65840
65841   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65842   {
65843     try {
65844       delete arg1;
65845     } catch (std::out_of_range& e) {
65846       {
65847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65848       };
65849     } catch (std::exception& e) {
65850       {
65851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65852       };
65853     } catch (...) {
65854       {
65855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65856       };
65857     }
65858   }
65859 }
65860
65861
65862 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_New() {
65863   void * jresult ;
65864   Dali::Toolkit::PushButton result;
65865
65866   {
65867     try {
65868       result = Dali::Toolkit::PushButton::New();
65869     } catch (std::out_of_range& e) {
65870       {
65871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65872       };
65873     } catch (std::exception& e) {
65874       {
65875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65876       };
65877     } catch (...) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65880       };
65881     }
65882   }
65883   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65884   return jresult;
65885 }
65886
65887
65888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_DownCast(void * jarg1) {
65889   void * jresult ;
65890   Dali::BaseHandle arg1 ;
65891   Dali::BaseHandle *argp1 ;
65892   Dali::Toolkit::PushButton result;
65893
65894   argp1 = (Dali::BaseHandle *)jarg1;
65895   if (!argp1) {
65896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65897     return 0;
65898   }
65899   arg1 = *argp1;
65900   {
65901     try {
65902       result = Dali::Toolkit::PushButton::DownCast(arg1);
65903     } catch (std::out_of_range& e) {
65904       {
65905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65906       };
65907     } catch (std::exception& e) {
65908       {
65909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65910       };
65911     } catch (...) {
65912       {
65913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65914       };
65915     }
65916   }
65917   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65918   return jresult;
65919 }
65920
65921
65922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65923   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65924   Dali::Image arg2 ;
65925   Dali::Image *argp2 ;
65926
65927   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65928   argp2 = (Dali::Image *)jarg2;
65929   if (!argp2) {
65930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65931     return ;
65932   }
65933   arg2 = *argp2;
65934   {
65935     try {
65936       (arg1)->SetButtonImage(arg2);
65937     } catch (std::out_of_range& e) {
65938       {
65939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65940       };
65941     } catch (std::exception& e) {
65942       {
65943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65944       };
65945     } catch (...) {
65946       {
65947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65948       };
65949     }
65950   }
65951 }
65952
65953
65954 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65955   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65956   Dali::Actor arg2 ;
65957   Dali::Actor *argp2 ;
65958
65959   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65960   argp2 = (Dali::Actor *)jarg2;
65961   if (!argp2) {
65962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65963     return ;
65964   }
65965   arg2 = *argp2;
65966   {
65967     try {
65968       (arg1)->SetButtonImage(arg2);
65969     } catch (std::out_of_range& e) {
65970       {
65971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65972       };
65973     } catch (std::exception& e) {
65974       {
65975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65976       };
65977     } catch (...) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65980       };
65981     }
65982   }
65983 }
65984
65985
65986 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65987   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65988   Dali::Actor arg2 ;
65989   Dali::Actor *argp2 ;
65990
65991   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65992   argp2 = (Dali::Actor *)jarg2;
65993   if (!argp2) {
65994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65995     return ;
65996   }
65997   arg2 = *argp2;
65998   {
65999     try {
66000       (arg1)->SetBackgroundImage(arg2);
66001     } catch (std::out_of_range& e) {
66002       {
66003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66004       };
66005     } catch (std::exception& e) {
66006       {
66007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66008       };
66009     } catch (...) {
66010       {
66011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66012       };
66013     }
66014   }
66015 }
66016
66017
66018 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66019   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66020   Dali::Image arg2 ;
66021   Dali::Image *argp2 ;
66022
66023   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66024   argp2 = (Dali::Image *)jarg2;
66025   if (!argp2) {
66026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66027     return ;
66028   }
66029   arg2 = *argp2;
66030   {
66031     try {
66032       (arg1)->SetSelectedImage(arg2);
66033     } catch (std::out_of_range& e) {
66034       {
66035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66036       };
66037     } catch (std::exception& e) {
66038       {
66039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66040       };
66041     } catch (...) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66044       };
66045     }
66046   }
66047 }
66048
66049
66050 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66051   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66052   Dali::Actor arg2 ;
66053   Dali::Actor *argp2 ;
66054
66055   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66056   argp2 = (Dali::Actor *)jarg2;
66057   if (!argp2) {
66058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66059     return ;
66060   }
66061   arg2 = *argp2;
66062   {
66063     try {
66064       (arg1)->SetSelectedImage(arg2);
66065     } catch (std::out_of_range& e) {
66066       {
66067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66068       };
66069     } catch (std::exception& e) {
66070       {
66071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66072       };
66073     } catch (...) {
66074       {
66075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66076       };
66077     }
66078   }
66079 }
66080
66081
66082 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66083   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66084   Dali::Actor arg2 ;
66085   Dali::Actor *argp2 ;
66086
66087   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66088   argp2 = (Dali::Actor *)jarg2;
66089   if (!argp2) {
66090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66091     return ;
66092   }
66093   arg2 = *argp2;
66094   {
66095     try {
66096       (arg1)->SetSelectedBackgroundImage(arg2);
66097     } catch (std::out_of_range& e) {
66098       {
66099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66100       };
66101     } catch (std::exception& e) {
66102       {
66103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66104       };
66105     } catch (...) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66108       };
66109     }
66110   }
66111 }
66112
66113
66114 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66115   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66116   Dali::Actor arg2 ;
66117   Dali::Actor *argp2 ;
66118
66119   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66120   argp2 = (Dali::Actor *)jarg2;
66121   if (!argp2) {
66122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66123     return ;
66124   }
66125   arg2 = *argp2;
66126   {
66127     try {
66128       (arg1)->SetDisabledBackgroundImage(arg2);
66129     } catch (std::out_of_range& e) {
66130       {
66131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66132       };
66133     } catch (std::exception& e) {
66134       {
66135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66140       };
66141     }
66142   }
66143 }
66144
66145
66146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66147   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66148   Dali::Actor arg2 ;
66149   Dali::Actor *argp2 ;
66150
66151   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66152   argp2 = (Dali::Actor *)jarg2;
66153   if (!argp2) {
66154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66155     return ;
66156   }
66157   arg2 = *argp2;
66158   {
66159     try {
66160       (arg1)->SetDisabledImage(arg2);
66161     } catch (std::out_of_range& e) {
66162       {
66163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66164       };
66165     } catch (std::exception& e) {
66166       {
66167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66168       };
66169     } catch (...) {
66170       {
66171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66172       };
66173     }
66174   }
66175 }
66176
66177
66178 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66179   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66180   Dali::Actor arg2 ;
66181   Dali::Actor *argp2 ;
66182
66183   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66184   argp2 = (Dali::Actor *)jarg2;
66185   if (!argp2) {
66186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66187     return ;
66188   }
66189   arg2 = *argp2;
66190   {
66191     try {
66192       (arg1)->SetDisabledSelectedImage(arg2);
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66200       };
66201     } catch (...) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66204       };
66205     }
66206   }
66207 }
66208
66209
66210 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RadioButton__SWIG_0() {
66211   void * jresult ;
66212   Dali::Toolkit::RadioButton *result = 0 ;
66213
66214   {
66215     try {
66216       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66217     } catch (std::out_of_range& e) {
66218       {
66219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66220       };
66221     } catch (std::exception& e) {
66222       {
66223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66224       };
66225     } catch (...) {
66226       {
66227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66228       };
66229     }
66230   }
66231   jresult = (void *)result;
66232   return jresult;
66233 }
66234
66235
66236 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RadioButton__SWIG_1(void * jarg1) {
66237   void * jresult ;
66238   Dali::Toolkit::RadioButton *arg1 = 0 ;
66239   Dali::Toolkit::RadioButton *result = 0 ;
66240
66241   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66242   if (!arg1) {
66243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66244     return 0;
66245   }
66246   {
66247     try {
66248       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66249     } catch (std::out_of_range& e) {
66250       {
66251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66252       };
66253     } catch (std::exception& e) {
66254       {
66255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66256       };
66257     } catch (...) {
66258       {
66259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66260       };
66261     }
66262   }
66263   jresult = (void *)result;
66264   return jresult;
66265 }
66266
66267
66268 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_Assign(void * jarg1, void * jarg2) {
66269   void * jresult ;
66270   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66271   Dali::Toolkit::RadioButton *arg2 = 0 ;
66272   Dali::Toolkit::RadioButton *result = 0 ;
66273
66274   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66275   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66276   if (!arg2) {
66277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66278     return 0;
66279   }
66280   {
66281     try {
66282       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66283     } catch (std::out_of_range& e) {
66284       {
66285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66286       };
66287     } catch (std::exception& e) {
66288       {
66289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66294       };
66295     }
66296   }
66297   jresult = (void *)result;
66298   return jresult;
66299 }
66300
66301
66302 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RadioButton(void * jarg1) {
66303   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66304
66305   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66306   {
66307     try {
66308       delete arg1;
66309     } catch (std::out_of_range& e) {
66310       {
66311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66312       };
66313     } catch (std::exception& e) {
66314       {
66315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66316       };
66317     } catch (...) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66320       };
66321     }
66322   }
66323 }
66324
66325
66326 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_New__SWIG_0() {
66327   void * jresult ;
66328   Dali::Toolkit::RadioButton result;
66329
66330   {
66331     try {
66332       result = Dali::Toolkit::RadioButton::New();
66333     } catch (std::out_of_range& e) {
66334       {
66335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (std::exception& e) {
66338       {
66339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66344       };
66345     }
66346   }
66347   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66348   return jresult;
66349 }
66350
66351
66352 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_New__SWIG_1(char * jarg1) {
66353   void * jresult ;
66354   std::string *arg1 = 0 ;
66355   Dali::Toolkit::RadioButton result;
66356
66357   if (!jarg1) {
66358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66359     return 0;
66360   }
66361   std::string arg1_str(jarg1);
66362   arg1 = &arg1_str;
66363   {
66364     try {
66365       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66377       };
66378     }
66379   }
66380   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66381
66382   //argout typemap for const std::string&
66383
66384   return jresult;
66385 }
66386
66387
66388 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_DownCast(void * jarg1) {
66389   void * jresult ;
66390   Dali::BaseHandle arg1 ;
66391   Dali::BaseHandle *argp1 ;
66392   Dali::Toolkit::RadioButton result;
66393
66394   argp1 = (Dali::BaseHandle *)jarg1;
66395   if (!argp1) {
66396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66397     return 0;
66398   }
66399   arg1 = *argp1;
66400   {
66401     try {
66402       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66403     } catch (std::out_of_range& e) {
66404       {
66405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66406       };
66407     } catch (std::exception& e) {
66408       {
66409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66414       };
66415     }
66416   }
66417   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66418   return jresult;
66419 }
66420
66421
66422 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_CONTENT_DIRECTION_get() {
66423   int jresult ;
66424   int result;
66425
66426   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66427   jresult = (int)result;
66428   return jresult;
66429 }
66430
66431
66432 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_FLEX_DIRECTION_get() {
66433   int jresult ;
66434   int result;
66435
66436   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66437   jresult = (int)result;
66438   return jresult;
66439 }
66440
66441
66442 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_FLEX_WRAP_get() {
66443   int jresult ;
66444   int result;
66445
66446   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66447   jresult = (int)result;
66448   return jresult;
66449 }
66450
66451
66452 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66453   int jresult ;
66454   int result;
66455
66456   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66457   jresult = (int)result;
66458   return jresult;
66459 }
66460
66461
66462 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_ALIGN_ITEMS_get() {
66463   int jresult ;
66464   int result;
66465
66466   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66467   jresult = (int)result;
66468   return jresult;
66469 }
66470
66471
66472 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_ALIGN_CONTENT_get() {
66473   int jresult ;
66474   int result;
66475
66476   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66477   jresult = (int)result;
66478   return jresult;
66479 }
66480
66481
66482 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer_Property() {
66483   void * jresult ;
66484   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66485
66486   {
66487     try {
66488       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
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_NUI_delete_FlexContainer_Property(void * jarg1) {
66509   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66510
66511   arg1 = (Dali::Toolkit::FlexContainer::Property *)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 int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_FLEX_get() {
66533   int jresult ;
66534   int result;
66535
66536   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66537   jresult = (int)result;
66538   return jresult;
66539 }
66540
66541
66542 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66543   int jresult ;
66544   int result;
66545
66546   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66547   jresult = (int)result;
66548   return jresult;
66549 }
66550
66551
66552 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66553   int jresult ;
66554   int result;
66555
66556   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66557   jresult = (int)result;
66558   return jresult;
66559 }
66560
66561
66562 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer_ChildProperty() {
66563   void * jresult ;
66564   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66565
66566   {
66567     try {
66568       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66569     } catch (std::out_of_range& e) {
66570       {
66571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66572       };
66573     } catch (std::exception& e) {
66574       {
66575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66576       };
66577     } catch (...) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66580       };
66581     }
66582   }
66583   jresult = (void *)result;
66584   return jresult;
66585 }
66586
66587
66588 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FlexContainer_ChildProperty(void * jarg1) {
66589   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66590
66591   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66592   {
66593     try {
66594       delete arg1;
66595     } catch (std::out_of_range& e) {
66596       {
66597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66598       };
66599     } catch (std::exception& e) {
66600       {
66601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66602       };
66603     } catch (...) {
66604       {
66605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66606       };
66607     }
66608   }
66609 }
66610
66611
66612 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer__SWIG_0() {
66613   void * jresult ;
66614   Dali::Toolkit::FlexContainer *result = 0 ;
66615
66616   {
66617     try {
66618       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66626       };
66627     } catch (...) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66630       };
66631     }
66632   }
66633   jresult = (void *)result;
66634   return jresult;
66635 }
66636
66637
66638 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer__SWIG_1(void * jarg1) {
66639   void * jresult ;
66640   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66641   Dali::Toolkit::FlexContainer *result = 0 ;
66642
66643   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66644   if (!arg1) {
66645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66646     return 0;
66647   }
66648   {
66649     try {
66650       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66651     } catch (std::out_of_range& e) {
66652       {
66653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66654       };
66655     } catch (std::exception& e) {
66656       {
66657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66658       };
66659     } catch (...) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66662       };
66663     }
66664   }
66665   jresult = (void *)result;
66666   return jresult;
66667 }
66668
66669
66670 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_Assign(void * jarg1, void * jarg2) {
66671   void * jresult ;
66672   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66673   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66674   Dali::Toolkit::FlexContainer *result = 0 ;
66675
66676   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66677   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66678   if (!arg2) {
66679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66680     return 0;
66681   }
66682   {
66683     try {
66684       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66685     } catch (std::out_of_range& e) {
66686       {
66687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66688       };
66689     } catch (std::exception& e) {
66690       {
66691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66692       };
66693     } catch (...) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66696       };
66697     }
66698   }
66699   jresult = (void *)result;
66700   return jresult;
66701 }
66702
66703
66704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FlexContainer(void * jarg1) {
66705   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66706
66707   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66708   {
66709     try {
66710       delete arg1;
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66718       };
66719     } catch (...) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66722       };
66723     }
66724   }
66725 }
66726
66727
66728 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_New() {
66729   void * jresult ;
66730   Dali::Toolkit::FlexContainer result;
66731
66732   {
66733     try {
66734       result = Dali::Toolkit::FlexContainer::New();
66735     } catch (std::out_of_range& e) {
66736       {
66737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66738       };
66739     } catch (std::exception& e) {
66740       {
66741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66742       };
66743     } catch (...) {
66744       {
66745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66746       };
66747     }
66748   }
66749   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66750   return jresult;
66751 }
66752
66753
66754 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_DownCast(void * jarg1) {
66755   void * jresult ;
66756   Dali::BaseHandle arg1 ;
66757   Dali::BaseHandle *argp1 ;
66758   Dali::Toolkit::FlexContainer result;
66759
66760   argp1 = (Dali::BaseHandle *)jarg1;
66761   if (!argp1) {
66762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66763     return 0;
66764   }
66765   arg1 = *argp1;
66766   {
66767     try {
66768       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66769     } catch (std::out_of_range& e) {
66770       {
66771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66772       };
66773     } catch (std::exception& e) {
66774       {
66775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66776       };
66777     } catch (...) {
66778       {
66779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66780       };
66781     }
66782   }
66783   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66784   return jresult;
66785 }
66786
66787
66788 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_RESOURCE_URL_get() {
66789   int jresult ;
66790   int result;
66791
66792   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66793   jresult = (int)result;
66794   return jresult;
66795 }
66796
66797
66798 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_IMAGE_get() {
66799   int jresult ;
66800   int result;
66801
66802   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66803   jresult = (int)result;
66804   return jresult;
66805 }
66806
66807
66808 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66809   int jresult ;
66810   int result;
66811
66812   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66813   jresult = (int)result;
66814   return jresult;
66815 }
66816
66817
66818 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_PIXEL_AREA_get() {
66819   int jresult ;
66820   int result;
66821
66822   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66823   jresult = (int)result;
66824   return jresult;
66825 }
66826
66827
66828 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView_Property() {
66829   void * jresult ;
66830   Dali::Toolkit::ImageView::Property *result = 0 ;
66831
66832   {
66833     try {
66834       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66835     } catch (std::out_of_range& e) {
66836       {
66837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66838       };
66839     } catch (std::exception& e) {
66840       {
66841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66842       };
66843     } catch (...) {
66844       {
66845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66846       };
66847     }
66848   }
66849   jresult = (void *)result;
66850   return jresult;
66851 }
66852
66853
66854 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageView_Property(void * jarg1) {
66855   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66856
66857   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66858   {
66859     try {
66860       delete arg1;
66861     } catch (std::out_of_range& e) {
66862       {
66863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66864       };
66865     } catch (std::exception& e) {
66866       {
66867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66868       };
66869     } catch (...) {
66870       {
66871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66872       };
66873     }
66874   }
66875 }
66876
66877
66878 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView__SWIG_0() {
66879   void * jresult ;
66880   Dali::Toolkit::ImageView *result = 0 ;
66881
66882   {
66883     try {
66884       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66885     } catch (std::out_of_range& e) {
66886       {
66887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66888       };
66889     } catch (std::exception& e) {
66890       {
66891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (...) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66896       };
66897     }
66898   }
66899   jresult = (void *)result;
66900   return jresult;
66901 }
66902
66903
66904 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_0() {
66905   void * jresult ;
66906   Dali::Toolkit::ImageView result;
66907
66908   {
66909     try {
66910       result = Dali::Toolkit::ImageView::New();
66911     } catch (std::out_of_range& e) {
66912       {
66913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66914       };
66915     } catch (std::exception& e) {
66916       {
66917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66918       };
66919     } catch (...) {
66920       {
66921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66922       };
66923     }
66924   }
66925   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66926   return jresult;
66927 }
66928
66929
66930 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_1(void * jarg1) {
66931   void * jresult ;
66932   Dali::Image arg1 ;
66933   Dali::Image *argp1 ;
66934   Dali::Toolkit::ImageView result;
66935
66936   argp1 = (Dali::Image *)jarg1;
66937   if (!argp1) {
66938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66939     return 0;
66940   }
66941   arg1 = *argp1;
66942   {
66943     try {
66944       result = Dali::Toolkit::ImageView::New(arg1);
66945     } catch (std::out_of_range& e) {
66946       {
66947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66948       };
66949     } catch (std::exception& e) {
66950       {
66951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (...) {
66954       {
66955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66956       };
66957     }
66958   }
66959   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66960   return jresult;
66961 }
66962
66963
66964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_2(char * jarg1) {
66965   void * jresult ;
66966   std::string *arg1 = 0 ;
66967   Dali::Toolkit::ImageView result;
66968
66969   if (!jarg1) {
66970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66971     return 0;
66972   }
66973   std::string arg1_str(jarg1);
66974   arg1 = &arg1_str;
66975   {
66976     try {
66977       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66978     } catch (std::out_of_range& e) {
66979       {
66980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66981       };
66982     } catch (std::exception& e) {
66983       {
66984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66985       };
66986     } catch (...) {
66987       {
66988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66989       };
66990     }
66991   }
66992   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66993
66994   //argout typemap for const std::string&
66995
66996   return jresult;
66997 }
66998
66999
67000 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67001   void * jresult ;
67002   std::string *arg1 = 0 ;
67003   Dali::ImageDimensions arg2 ;
67004   Dali::ImageDimensions *argp2 ;
67005   Dali::Toolkit::ImageView result;
67006
67007   if (!jarg1) {
67008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67009     return 0;
67010   }
67011   std::string arg1_str(jarg1);
67012   arg1 = &arg1_str;
67013   argp2 = (Dali::ImageDimensions *)jarg2;
67014   if (!argp2) {
67015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67016     return 0;
67017   }
67018   arg2 = *argp2;
67019   {
67020     try {
67021       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67022     } catch (std::out_of_range& e) {
67023       {
67024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67025       };
67026     } catch (std::exception& e) {
67027       {
67028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67029       };
67030     } catch (...) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67033       };
67034     }
67035   }
67036   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67037
67038   //argout typemap for const std::string&
67039
67040   return jresult;
67041 }
67042
67043
67044 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageView(void * jarg1) {
67045   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67046
67047   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67048   {
67049     try {
67050       delete arg1;
67051     } catch (std::out_of_range& e) {
67052       {
67053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67054       };
67055     } catch (std::exception& e) {
67056       {
67057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67058       };
67059     } catch (...) {
67060       {
67061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67062       };
67063     }
67064   }
67065 }
67066
67067
67068 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView__SWIG_1(void * jarg1) {
67069   void * jresult ;
67070   Dali::Toolkit::ImageView *arg1 = 0 ;
67071   Dali::Toolkit::ImageView *result = 0 ;
67072
67073   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67074   if (!arg1) {
67075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67076     return 0;
67077   }
67078   {
67079     try {
67080       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67081     } catch (std::out_of_range& e) {
67082       {
67083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67084       };
67085     } catch (std::exception& e) {
67086       {
67087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67088       };
67089     } catch (...) {
67090       {
67091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67092       };
67093     }
67094   }
67095   jresult = (void *)result;
67096   return jresult;
67097 }
67098
67099
67100 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_Assign(void * jarg1, void * jarg2) {
67101   void * jresult ;
67102   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67103   Dali::Toolkit::ImageView *arg2 = 0 ;
67104   Dali::Toolkit::ImageView *result = 0 ;
67105
67106   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67107   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67108   if (!arg2) {
67109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67110     return 0;
67111   }
67112   {
67113     try {
67114       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67115     } catch (std::out_of_range& e) {
67116       {
67117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67118       };
67119     } catch (std::exception& e) {
67120       {
67121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67122       };
67123     } catch (...) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67126       };
67127     }
67128   }
67129   jresult = (void *)result;
67130   return jresult;
67131 }
67132
67133
67134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_DownCast(void * jarg1) {
67135   void * jresult ;
67136   Dali::BaseHandle arg1 ;
67137   Dali::BaseHandle *argp1 ;
67138   Dali::Toolkit::ImageView result;
67139
67140   argp1 = (Dali::BaseHandle *)jarg1;
67141   if (!argp1) {
67142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67143     return 0;
67144   }
67145   arg1 = *argp1;
67146   {
67147     try {
67148       result = Dali::Toolkit::ImageView::DownCast(arg1);
67149     } catch (std::out_of_range& e) {
67150       {
67151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67152       };
67153     } catch (std::exception& e) {
67154       {
67155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67156       };
67157     } catch (...) {
67158       {
67159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67160       };
67161     }
67162   }
67163   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67164   return jresult;
67165 }
67166
67167
67168 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67169   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67170   Dali::Image arg2 ;
67171   Dali::Image *argp2 ;
67172
67173   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67174   argp2 = (Dali::Image *)jarg2;
67175   if (!argp2) {
67176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67177     return ;
67178   }
67179   arg2 = *argp2;
67180   {
67181     try {
67182       (arg1)->SetImage(arg2);
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67194       };
67195     }
67196   }
67197 }
67198
67199
67200 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67201   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67202   std::string *arg2 = 0 ;
67203
67204   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67205   if (!jarg2) {
67206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67207     return ;
67208   }
67209   std::string arg2_str(jarg2);
67210   arg2 = &arg2_str;
67211   {
67212     try {
67213       (arg1)->SetImage((std::string const &)*arg2);
67214     } catch (std::out_of_range& e) {
67215       {
67216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67217       };
67218     } catch (std::exception& e) {
67219       {
67220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67221       };
67222     } catch (...) {
67223       {
67224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67225       };
67226     }
67227   }
67228
67229   //argout typemap for const std::string&
67230
67231 }
67232
67233
67234 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67235   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67236   std::string *arg2 = 0 ;
67237   Dali::ImageDimensions arg3 ;
67238   Dali::ImageDimensions *argp3 ;
67239
67240   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67241   if (!jarg2) {
67242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67243     return ;
67244   }
67245   std::string arg2_str(jarg2);
67246   arg2 = &arg2_str;
67247   argp3 = (Dali::ImageDimensions *)jarg3;
67248   if (!argp3) {
67249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67250     return ;
67251   }
67252   arg3 = *argp3;
67253   {
67254     try {
67255       (arg1)->SetImage((std::string const &)*arg2,arg3);
67256     } catch (std::out_of_range& e) {
67257       {
67258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67259       };
67260     } catch (std::exception& e) {
67261       {
67262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67267       };
67268     }
67269   }
67270
67271   //argout typemap for const std::string&
67272
67273 }
67274
67275
67276 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_GetImage(void * jarg1) {
67277   void * jresult ;
67278   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67279   Dali::Image result;
67280
67281   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67282   {
67283     try {
67284       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67285     } catch (std::out_of_range& e) {
67286       {
67287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67288       };
67289     } catch (std::exception& e) {
67290       {
67291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67292       };
67293     } catch (...) {
67294       {
67295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67296       };
67297     }
67298   }
67299   jresult = new Dali::Image((const Dali::Image &)result);
67300   return jresult;
67301 }
67302
67303
67304 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_GEOMETRY_URL_get() {
67305   int jresult ;
67306   int result;
67307
67308   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67309   jresult = (int)result;
67310   return jresult;
67311 }
67312
67313
67314 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_MATERIAL_URL_get() {
67315   int jresult ;
67316   int result;
67317
67318   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67319   jresult = (int)result;
67320   return jresult;
67321 }
67322
67323
67324 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_IMAGES_URL_get() {
67325   int jresult ;
67326   int result;
67327
67328   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67329   jresult = (int)result;
67330   return jresult;
67331 }
67332
67333
67334 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_ILLUMINATION_TYPE_get() {
67335   int jresult ;
67336   int result;
67337
67338   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67339   jresult = (int)result;
67340   return jresult;
67341 }
67342
67343
67344 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE0_URL_get() {
67345   int jresult ;
67346   int result;
67347
67348   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67349   jresult = (int)result;
67350   return jresult;
67351 }
67352
67353
67354 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE1_URL_get() {
67355   int jresult ;
67356   int result;
67357
67358   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67359   jresult = (int)result;
67360   return jresult;
67361 }
67362
67363
67364 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE2_URL_get() {
67365   int jresult ;
67366   int result;
67367
67368   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67369   jresult = (int)result;
67370   return jresult;
67371 }
67372
67373
67374 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_LIGHT_POSITION_get() {
67375   int jresult ;
67376   int result;
67377
67378   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67379   jresult = (int)result;
67380   return jresult;
67381 }
67382
67383
67384 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView_Property() {
67385   void * jresult ;
67386   Dali::Toolkit::Model3dView::Property *result = 0 ;
67387
67388   {
67389     try {
67390       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67391     } catch (std::out_of_range& e) {
67392       {
67393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67394       };
67395     } catch (std::exception& e) {
67396       {
67397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67398       };
67399     } catch (...) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67402       };
67403     }
67404   }
67405   jresult = (void *)result;
67406   return jresult;
67407 }
67408
67409
67410 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Model3dView_Property(void * jarg1) {
67411   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67412
67413   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67414   {
67415     try {
67416       delete arg1;
67417     } catch (std::out_of_range& e) {
67418       {
67419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67420       };
67421     } catch (std::exception& e) {
67422       {
67423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67424       };
67425     } catch (...) {
67426       {
67427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67428       };
67429     }
67430   }
67431 }
67432
67433
67434 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_New__SWIG_0() {
67435   void * jresult ;
67436   Dali::Toolkit::Model3dView result;
67437
67438   {
67439     try {
67440       result = Dali::Toolkit::Model3dView::New();
67441     } catch (std::out_of_range& e) {
67442       {
67443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67444       };
67445     } catch (std::exception& e) {
67446       {
67447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67448       };
67449     } catch (...) {
67450       {
67451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67452       };
67453     }
67454   }
67455   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67456   return jresult;
67457 }
67458
67459
67460 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67461   void * jresult ;
67462   std::string *arg1 = 0 ;
67463   std::string *arg2 = 0 ;
67464   std::string *arg3 = 0 ;
67465   Dali::Toolkit::Model3dView result;
67466
67467   if (!jarg1) {
67468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67469     return 0;
67470   }
67471   std::string arg1_str(jarg1);
67472   arg1 = &arg1_str;
67473   if (!jarg2) {
67474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67475     return 0;
67476   }
67477   std::string arg2_str(jarg2);
67478   arg2 = &arg2_str;
67479   if (!jarg3) {
67480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67481     return 0;
67482   }
67483   std::string arg3_str(jarg3);
67484   arg3 = &arg3_str;
67485   {
67486     try {
67487       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67488     } catch (std::out_of_range& e) {
67489       {
67490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67491       };
67492     } catch (std::exception& e) {
67493       {
67494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67495       };
67496     } catch (...) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67499       };
67500     }
67501   }
67502   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67503
67504   //argout typemap for const std::string&
67505
67506
67507   //argout typemap for const std::string&
67508
67509
67510   //argout typemap for const std::string&
67511
67512   return jresult;
67513 }
67514
67515
67516 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView__SWIG_0() {
67517   void * jresult ;
67518   Dali::Toolkit::Model3dView *result = 0 ;
67519
67520   {
67521     try {
67522       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67523     } catch (std::out_of_range& e) {
67524       {
67525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (std::exception& e) {
67528       {
67529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (...) {
67532       {
67533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67534       };
67535     }
67536   }
67537   jresult = (void *)result;
67538   return jresult;
67539 }
67540
67541
67542 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Model3dView(void * jarg1) {
67543   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67544
67545   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67546   {
67547     try {
67548       delete arg1;
67549     } catch (std::out_of_range& e) {
67550       {
67551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67552       };
67553     } catch (std::exception& e) {
67554       {
67555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67556       };
67557     } catch (...) {
67558       {
67559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67560       };
67561     }
67562   }
67563 }
67564
67565
67566 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView__SWIG_1(void * jarg1) {
67567   void * jresult ;
67568   Dali::Toolkit::Model3dView *arg1 = 0 ;
67569   Dali::Toolkit::Model3dView *result = 0 ;
67570
67571   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67572   if (!arg1) {
67573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67574     return 0;
67575   }
67576   {
67577     try {
67578       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67579     } catch (std::out_of_range& e) {
67580       {
67581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67582       };
67583     } catch (std::exception& e) {
67584       {
67585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67586       };
67587     } catch (...) {
67588       {
67589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67590       };
67591     }
67592   }
67593   jresult = (void *)result;
67594   return jresult;
67595 }
67596
67597
67598 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_Assign(void * jarg1, void * jarg2) {
67599   void * jresult ;
67600   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67601   Dali::Toolkit::Model3dView *arg2 = 0 ;
67602   Dali::Toolkit::Model3dView *result = 0 ;
67603
67604   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67605   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67606   if (!arg2) {
67607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67608     return 0;
67609   }
67610   {
67611     try {
67612       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67613     } catch (std::out_of_range& e) {
67614       {
67615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67616       };
67617     } catch (std::exception& e) {
67618       {
67619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67620       };
67621     } catch (...) {
67622       {
67623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67624       };
67625     }
67626   }
67627   jresult = (void *)result;
67628   return jresult;
67629 }
67630
67631
67632 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_DownCast(void * jarg1) {
67633   void * jresult ;
67634   Dali::BaseHandle arg1 ;
67635   Dali::BaseHandle *argp1 ;
67636   Dali::Toolkit::Model3dView result;
67637
67638   argp1 = (Dali::BaseHandle *)jarg1;
67639   if (!argp1) {
67640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67641     return 0;
67642   }
67643   arg1 = *argp1;
67644   {
67645     try {
67646       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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 int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_SCROLL_DIRECTION_get() {
67667   int jresult ;
67668   int result;
67669
67670   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67671   jresult = (int)result;
67672   return jresult;
67673 }
67674
67675
67676 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67677   int jresult ;
67678   int result;
67679
67680   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67681   jresult = (int)result;
67682   return jresult;
67683 }
67684
67685
67686 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67687   int jresult ;
67688   int result;
67689
67690   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67691   jresult = (int)result;
67692   return jresult;
67693 }
67694
67695
67696 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67697   int jresult ;
67698   int result;
67699
67700   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67701   jresult = (int)result;
67702   return jresult;
67703 }
67704
67705
67706 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67707   int jresult ;
67708   int result;
67709
67710   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67711   jresult = (int)result;
67712   return jresult;
67713 }
67714
67715
67716 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67717   int jresult ;
67718   int result;
67719
67720   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67721   jresult = (int)result;
67722   return jresult;
67723 }
67724
67725
67726 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67727   int jresult ;
67728   int result;
67729
67730   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67731   jresult = (int)result;
67732   return jresult;
67733 }
67734
67735
67736 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67737   int jresult ;
67738   int result;
67739
67740   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67741   jresult = (int)result;
67742   return jresult;
67743 }
67744
67745
67746 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67747   int jresult ;
67748   int result;
67749
67750   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67751   jresult = (int)result;
67752   return jresult;
67753 }
67754
67755
67756 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar_Property() {
67757   void * jresult ;
67758   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67759
67760   {
67761     try {
67762       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67763     } catch (std::out_of_range& e) {
67764       {
67765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67766       };
67767     } catch (std::exception& e) {
67768       {
67769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67770       };
67771     } catch (...) {
67772       {
67773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67774       };
67775     }
67776   }
67777   jresult = (void *)result;
67778   return jresult;
67779 }
67780
67781
67782 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollBar_Property(void * jarg1) {
67783   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67784
67785   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67786   {
67787     try {
67788       delete arg1;
67789     } catch (std::out_of_range& e) {
67790       {
67791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67792       };
67793     } catch (std::exception& e) {
67794       {
67795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67800       };
67801     }
67802   }
67803 }
67804
67805
67806 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar__SWIG_0() {
67807   void * jresult ;
67808   Dali::Toolkit::ScrollBar *result = 0 ;
67809
67810   {
67811     try {
67812       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67813     } catch (std::out_of_range& e) {
67814       {
67815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67816       };
67817     } catch (std::exception& e) {
67818       {
67819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67824       };
67825     }
67826   }
67827   jresult = (void *)result;
67828   return jresult;
67829 }
67830
67831
67832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar__SWIG_1(void * jarg1) {
67833   void * jresult ;
67834   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67835   Dali::Toolkit::ScrollBar *result = 0 ;
67836
67837   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67838   if (!arg1) {
67839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67840     return 0;
67841   }
67842   {
67843     try {
67844       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67845     } catch (std::out_of_range& e) {
67846       {
67847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67848       };
67849     } catch (std::exception& e) {
67850       {
67851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67852       };
67853     } catch (...) {
67854       {
67855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67856       };
67857     }
67858   }
67859   jresult = (void *)result;
67860   return jresult;
67861 }
67862
67863
67864 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_Assign(void * jarg1, void * jarg2) {
67865   void * jresult ;
67866   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67867   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67868   Dali::Toolkit::ScrollBar *result = 0 ;
67869
67870   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67871   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67872   if (!arg2) {
67873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67874     return 0;
67875   }
67876   {
67877     try {
67878       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67879     } catch (std::out_of_range& e) {
67880       {
67881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (std::exception& e) {
67884       {
67885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67886       };
67887     } catch (...) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67890       };
67891     }
67892   }
67893   jresult = (void *)result;
67894   return jresult;
67895 }
67896
67897
67898 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollBar(void * jarg1) {
67899   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67900
67901   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67902   {
67903     try {
67904       delete arg1;
67905     } catch (std::out_of_range& e) {
67906       {
67907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67908       };
67909     } catch (std::exception& e) {
67910       {
67911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67912       };
67913     } catch (...) {
67914       {
67915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67916       };
67917     }
67918   }
67919 }
67920
67921
67922 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_New__SWIG_0(int jarg1) {
67923   void * jresult ;
67924   Dali::Toolkit::ScrollBar::Direction arg1 ;
67925   Dali::Toolkit::ScrollBar result;
67926
67927   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67928   {
67929     try {
67930       result = Dali::Toolkit::ScrollBar::New(arg1);
67931     } catch (std::out_of_range& e) {
67932       {
67933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67934       };
67935     } catch (std::exception& e) {
67936       {
67937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67938       };
67939     } catch (...) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67942       };
67943     }
67944   }
67945   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67946   return jresult;
67947 }
67948
67949
67950 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_New__SWIG_1() {
67951   void * jresult ;
67952   Dali::Toolkit::ScrollBar result;
67953
67954   {
67955     try {
67956       result = Dali::Toolkit::ScrollBar::New();
67957     } catch (std::out_of_range& e) {
67958       {
67959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67960       };
67961     } catch (std::exception& e) {
67962       {
67963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67964       };
67965     } catch (...) {
67966       {
67967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67968       };
67969     }
67970   }
67971   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67972   return jresult;
67973 }
67974
67975
67976 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_DownCast(void * jarg1) {
67977   void * jresult ;
67978   Dali::BaseHandle arg1 ;
67979   Dali::BaseHandle *argp1 ;
67980   Dali::Toolkit::ScrollBar result;
67981
67982   argp1 = (Dali::BaseHandle *)jarg1;
67983   if (!argp1) {
67984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67985     return 0;
67986   }
67987   arg1 = *argp1;
67988   {
67989     try {
67990       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67991     } catch (std::out_of_range& e) {
67992       {
67993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67994       };
67995     } catch (std::exception& e) {
67996       {
67997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67998       };
67999     } catch (...) {
68000       {
68001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68002       };
68003     }
68004   }
68005   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68006   return jresult;
68007 }
68008
68009
68010 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68011   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68012   Dali::Handle arg2 ;
68013   Dali::Property::Index arg3 ;
68014   Dali::Property::Index arg4 ;
68015   Dali::Property::Index arg5 ;
68016   Dali::Property::Index arg6 ;
68017   Dali::Handle *argp2 ;
68018
68019   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68020   argp2 = (Dali::Handle *)jarg2;
68021   if (!argp2) {
68022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68023     return ;
68024   }
68025   arg2 = *argp2;
68026   arg3 = (Dali::Property::Index)jarg3;
68027   arg4 = (Dali::Property::Index)jarg4;
68028   arg5 = (Dali::Property::Index)jarg5;
68029   arg6 = (Dali::Property::Index)jarg6;
68030   {
68031     try {
68032       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68033     } catch (std::out_of_range& e) {
68034       {
68035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68036       };
68037     } catch (std::exception& e) {
68038       {
68039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68040       };
68041     } catch (...) {
68042       {
68043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68044       };
68045     }
68046   }
68047 }
68048
68049
68050 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68051   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68052   Dali::Actor arg2 ;
68053   Dali::Actor *argp2 ;
68054
68055   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68056   argp2 = (Dali::Actor *)jarg2;
68057   if (!argp2) {
68058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68059     return ;
68060   }
68061   arg2 = *argp2;
68062   {
68063     try {
68064       (arg1)->SetScrollIndicator(arg2);
68065     } catch (std::out_of_range& e) {
68066       {
68067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68068       };
68069     } catch (std::exception& e) {
68070       {
68071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68072       };
68073     } catch (...) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68076       };
68077     }
68078   }
68079 }
68080
68081
68082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollIndicator(void * jarg1) {
68083   void * jresult ;
68084   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68085   Dali::Actor result;
68086
68087   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68088   {
68089     try {
68090       result = (arg1)->GetScrollIndicator();
68091     } catch (std::out_of_range& e) {
68092       {
68093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68094       };
68095     } catch (std::exception& e) {
68096       {
68097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68098       };
68099     } catch (...) {
68100       {
68101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68102       };
68103     }
68104   }
68105   jresult = new Dali::Actor((const Dali::Actor &)result);
68106   return jresult;
68107 }
68108
68109
68110 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68111   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68112   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68113
68114   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68115   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68116   if (!arg2) {
68117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68118     return ;
68119   }
68120   {
68121     try {
68122       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68123     } catch (std::out_of_range& e) {
68124       {
68125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68126       };
68127     } catch (std::exception& e) {
68128       {
68129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68130       };
68131     } catch (...) {
68132       {
68133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68134       };
68135     }
68136   }
68137 }
68138
68139
68140 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68141   void * jresult ;
68142   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68143   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68144
68145   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68146   {
68147     try {
68148       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68149     } catch (std::out_of_range& e) {
68150       {
68151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68152       };
68153     } catch (std::exception& e) {
68154       {
68155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68156       };
68157     } catch (...) {
68158       {
68159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68160       };
68161     }
68162   }
68163   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68164   return jresult;
68165 }
68166
68167
68168 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68169   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68170   Dali::Toolkit::ScrollBar::Direction arg2 ;
68171
68172   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68173   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68174   {
68175     try {
68176       (arg1)->SetScrollDirection(arg2);
68177     } catch (std::out_of_range& e) {
68178       {
68179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68180       };
68181     } catch (std::exception& e) {
68182       {
68183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68184       };
68185     } catch (...) {
68186       {
68187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68188       };
68189     }
68190   }
68191 }
68192
68193
68194 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollDirection(void * jarg1) {
68195   int jresult ;
68196   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68197   Dali::Toolkit::ScrollBar::Direction result;
68198
68199   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68200   {
68201     try {
68202       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68203     } catch (std::out_of_range& e) {
68204       {
68205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68206       };
68207     } catch (std::exception& e) {
68208       {
68209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68210       };
68211     } catch (...) {
68212       {
68213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68214       };
68215     }
68216   }
68217   jresult = (int)result;
68218   return jresult;
68219 }
68220
68221
68222 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68223   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68224   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68225
68226   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68227   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68228   {
68229     try {
68230       (arg1)->SetIndicatorHeightPolicy(arg2);
68231     } catch (std::out_of_range& e) {
68232       {
68233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68234       };
68235     } catch (std::exception& e) {
68236       {
68237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68242       };
68243     }
68244   }
68245 }
68246
68247
68248 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68249   int jresult ;
68250   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68251   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68252
68253   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68254   {
68255     try {
68256       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68257     } catch (std::out_of_range& e) {
68258       {
68259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68260       };
68261     } catch (std::exception& e) {
68262       {
68263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68264       };
68265     } catch (...) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68268       };
68269     }
68270   }
68271   jresult = (int)result;
68272   return jresult;
68273 }
68274
68275
68276 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68278   float arg2 ;
68279
68280   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68281   arg2 = (float)jarg2;
68282   {
68283     try {
68284       (arg1)->SetIndicatorFixedHeight(arg2);
68285     } catch (std::out_of_range& e) {
68286       {
68287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68288       };
68289     } catch (std::exception& e) {
68290       {
68291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68292       };
68293     } catch (...) {
68294       {
68295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68296       };
68297     }
68298   }
68299 }
68300
68301
68302 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68303   float jresult ;
68304   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68305   float result;
68306
68307   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68308   {
68309     try {
68310       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68311     } catch (std::out_of_range& e) {
68312       {
68313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68314       };
68315     } catch (std::exception& e) {
68316       {
68317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68318       };
68319     } catch (...) {
68320       {
68321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68322       };
68323     }
68324   }
68325   jresult = result;
68326   return jresult;
68327 }
68328
68329
68330 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68331   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68332   float arg2 ;
68333
68334   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68335   arg2 = (float)jarg2;
68336   {
68337     try {
68338       (arg1)->SetIndicatorShowDuration(arg2);
68339     } catch (std::out_of_range& e) {
68340       {
68341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68342       };
68343     } catch (std::exception& e) {
68344       {
68345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68346       };
68347     } catch (...) {
68348       {
68349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68350       };
68351     }
68352   }
68353 }
68354
68355
68356 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68357   float jresult ;
68358   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68359   float result;
68360
68361   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68362   {
68363     try {
68364       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68365     } catch (std::out_of_range& e) {
68366       {
68367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68368       };
68369     } catch (std::exception& e) {
68370       {
68371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68372       };
68373     } catch (...) {
68374       {
68375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68376       };
68377     }
68378   }
68379   jresult = result;
68380   return jresult;
68381 }
68382
68383
68384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68385   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68386   float arg2 ;
68387
68388   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68389   arg2 = (float)jarg2;
68390   {
68391     try {
68392       (arg1)->SetIndicatorHideDuration(arg2);
68393     } catch (std::out_of_range& e) {
68394       {
68395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68396       };
68397     } catch (std::exception& e) {
68398       {
68399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68400       };
68401     } catch (...) {
68402       {
68403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68404       };
68405     }
68406   }
68407 }
68408
68409
68410 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68411   float jresult ;
68412   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68413   float result;
68414
68415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68416   {
68417     try {
68418       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68419     } catch (std::out_of_range& e) {
68420       {
68421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68422       };
68423     } catch (std::exception& e) {
68424       {
68425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68426       };
68427     } catch (...) {
68428       {
68429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68430       };
68431     }
68432   }
68433   jresult = result;
68434   return jresult;
68435 }
68436
68437
68438 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_ShowIndicator(void * jarg1) {
68439   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68440
68441   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68442   {
68443     try {
68444       (arg1)->ShowIndicator();
68445     } catch (std::out_of_range& e) {
68446       {
68447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68448       };
68449     } catch (std::exception& e) {
68450       {
68451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68452       };
68453     } catch (...) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68456       };
68457     }
68458   }
68459 }
68460
68461
68462 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_HideIndicator(void * jarg1) {
68463   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68464
68465   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68466   {
68467     try {
68468       (arg1)->HideIndicator();
68469     } catch (std::out_of_range& e) {
68470       {
68471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68472       };
68473     } catch (std::exception& e) {
68474       {
68475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68476       };
68477     } catch (...) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68480       };
68481     }
68482   }
68483 }
68484
68485
68486 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_PanFinishedSignal(void * jarg1) {
68487   void * jresult ;
68488   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68489   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68490
68491   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68492   {
68493     try {
68494       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68495     } catch (std::out_of_range& e) {
68496       {
68497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68498       };
68499     } catch (std::exception& e) {
68500       {
68501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68502       };
68503     } catch (...) {
68504       {
68505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68506       };
68507     }
68508   }
68509   jresult = (void *)result;
68510   return jresult;
68511 }
68512
68513
68514 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68515   void * jresult ;
68516   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68517   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68518
68519   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68520   {
68521     try {
68522       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (...) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68534       };
68535     }
68536   }
68537   jresult = (void *)result;
68538   return jresult;
68539 }
68540
68541
68542 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68543   int jresult ;
68544   int result;
68545
68546   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68547   jresult = (int)result;
68548   return jresult;
68549 }
68550
68551
68552 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68553   int jresult ;
68554   int result;
68555
68556   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68557   jresult = (int)result;
68558   return jresult;
68559 }
68560
68561
68562 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68563   int jresult ;
68564   int result;
68565
68566   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68567   jresult = (int)result;
68568   return jresult;
68569 }
68570
68571
68572 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_SIZE_get() {
68573   int jresult ;
68574   int result;
68575
68576   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68577   jresult = (int)result;
68578   return jresult;
68579 }
68580
68581
68582 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68583   int jresult ;
68584   int result;
68585
68586   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68587   jresult = (int)result;
68588   return jresult;
68589 }
68590
68591
68592 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68593   int jresult ;
68594   int result;
68595
68596   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68597   jresult = (int)result;
68598   return jresult;
68599 }
68600
68601
68602 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68603   int jresult ;
68604   int result;
68605
68606   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68607   jresult = (int)result;
68608   return jresult;
68609 }
68610
68611
68612 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68613   int jresult ;
68614   int result;
68615
68616   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68617   jresult = (int)result;
68618   return jresult;
68619 }
68620
68621
68622 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68623   int jresult ;
68624   int result;
68625
68626   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68627   jresult = (int)result;
68628   return jresult;
68629 }
68630
68631
68632 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68633   int jresult ;
68634   int result;
68635
68636   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68637   jresult = (int)result;
68638   return jresult;
68639 }
68640
68641
68642 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68643   int jresult ;
68644   int result;
68645
68646   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68647   jresult = (int)result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68653   int jresult ;
68654   int result;
68655
68656   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68657   jresult = (int)result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68663   int jresult ;
68664   int result;
68665
68666   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68667   jresult = (int)result;
68668   return jresult;
68669 }
68670
68671
68672 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68673   int jresult ;
68674   int result;
68675
68676   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68677   jresult = (int)result;
68678   return jresult;
68679 }
68680
68681
68682 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable_Property() {
68683   void * jresult ;
68684   Dali::Toolkit::Scrollable::Property *result = 0 ;
68685
68686   {
68687     try {
68688       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68689     } catch (std::out_of_range& e) {
68690       {
68691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68692       };
68693     } catch (std::exception& e) {
68694       {
68695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68696       };
68697     } catch (...) {
68698       {
68699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68700       };
68701     }
68702   }
68703   jresult = (void *)result;
68704   return jresult;
68705 }
68706
68707
68708 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Scrollable_Property(void * jarg1) {
68709   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68710
68711   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68712   {
68713     try {
68714       delete arg1;
68715     } catch (std::out_of_range& e) {
68716       {
68717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68718       };
68719     } catch (std::exception& e) {
68720       {
68721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68722       };
68723     } catch (...) {
68724       {
68725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68726       };
68727     }
68728   }
68729 }
68730
68731
68732 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable__SWIG_0() {
68733   void * jresult ;
68734   Dali::Toolkit::Scrollable *result = 0 ;
68735
68736   {
68737     try {
68738       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68739     } catch (std::out_of_range& e) {
68740       {
68741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68742       };
68743     } catch (std::exception& e) {
68744       {
68745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68746       };
68747     } catch (...) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68750       };
68751     }
68752   }
68753   jresult = (void *)result;
68754   return jresult;
68755 }
68756
68757
68758 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable__SWIG_1(void * jarg1) {
68759   void * jresult ;
68760   Dali::Toolkit::Scrollable *arg1 = 0 ;
68761   Dali::Toolkit::Scrollable *result = 0 ;
68762
68763   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68764   if (!arg1) {
68765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68766     return 0;
68767   }
68768   {
68769     try {
68770       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68771     } catch (std::out_of_range& e) {
68772       {
68773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68774       };
68775     } catch (std::exception& e) {
68776       {
68777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68778       };
68779     } catch (...) {
68780       {
68781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68782       };
68783     }
68784   }
68785   jresult = (void *)result;
68786   return jresult;
68787 }
68788
68789
68790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_Assign(void * jarg1, void * jarg2) {
68791   void * jresult ;
68792   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68793   Dali::Toolkit::Scrollable *arg2 = 0 ;
68794   Dali::Toolkit::Scrollable *result = 0 ;
68795
68796   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68797   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68798   if (!arg2) {
68799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68800     return 0;
68801   }
68802   {
68803     try {
68804       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68805     } catch (std::out_of_range& e) {
68806       {
68807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68808       };
68809     } catch (std::exception& e) {
68810       {
68811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68812       };
68813     } catch (...) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68816       };
68817     }
68818   }
68819   jresult = (void *)result;
68820   return jresult;
68821 }
68822
68823
68824 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Scrollable(void * jarg1) {
68825   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68826
68827   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68828   {
68829     try {
68830       delete arg1;
68831     } catch (std::out_of_range& e) {
68832       {
68833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68834       };
68835     } catch (std::exception& e) {
68836       {
68837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68838       };
68839     } catch (...) {
68840       {
68841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68842       };
68843     }
68844   }
68845 }
68846
68847
68848 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_DownCast(void * jarg1) {
68849   void * jresult ;
68850   Dali::BaseHandle arg1 ;
68851   Dali::BaseHandle *argp1 ;
68852   Dali::Toolkit::Scrollable result;
68853
68854   argp1 = (Dali::BaseHandle *)jarg1;
68855   if (!argp1) {
68856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68857     return 0;
68858   }
68859   arg1 = *argp1;
68860   {
68861     try {
68862       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68863     } catch (std::out_of_range& e) {
68864       {
68865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (std::exception& e) {
68868       {
68869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (...) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68874       };
68875     }
68876   }
68877   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68878   return jresult;
68879 }
68880
68881
68882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Scrollable_IsOvershootEnabled(void * jarg1) {
68883   unsigned int jresult ;
68884   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68885   bool result;
68886
68887   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68888   {
68889     try {
68890       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68891     } catch (std::out_of_range& e) {
68892       {
68893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68894       };
68895     } catch (std::exception& e) {
68896       {
68897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68898       };
68899     } catch (...) {
68900       {
68901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68902       };
68903     }
68904   }
68905   jresult = result;
68906   return jresult;
68907 }
68908
68909
68910 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68911   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68912   bool arg2 ;
68913
68914   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68915   arg2 = jarg2 ? true : false;
68916   {
68917     try {
68918       (arg1)->SetOvershootEnabled(arg2);
68919     } catch (std::out_of_range& e) {
68920       {
68921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68922       };
68923     } catch (std::exception& e) {
68924       {
68925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68926       };
68927     } catch (...) {
68928       {
68929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68930       };
68931     }
68932   }
68933 }
68934
68935
68936 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68937   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68938   Dali::Vector4 *arg2 = 0 ;
68939
68940   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68941   arg2 = (Dali::Vector4 *)jarg2;
68942   if (!arg2) {
68943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68944     return ;
68945   }
68946   {
68947     try {
68948       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68949     } catch (std::out_of_range& e) {
68950       {
68951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68952       };
68953     } catch (std::exception& e) {
68954       {
68955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68956       };
68957     } catch (...) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68960       };
68961     }
68962   }
68963 }
68964
68965
68966 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_GetOvershootEffectColor(void * jarg1) {
68967   void * jresult ;
68968   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68969   Dali::Vector4 result;
68970
68971   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68972   {
68973     try {
68974       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68975     } catch (std::out_of_range& e) {
68976       {
68977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68978       };
68979     } catch (std::exception& e) {
68980       {
68981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68982       };
68983     } catch (...) {
68984       {
68985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68986       };
68987     }
68988   }
68989   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68990   return jresult;
68991 }
68992
68993
68994 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68995   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68996   float arg2 ;
68997
68998   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68999   arg2 = (float)jarg2;
69000   {
69001     try {
69002       (arg1)->SetOvershootAnimationSpeed(arg2);
69003     } catch (std::out_of_range& e) {
69004       {
69005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69006       };
69007     } catch (std::exception& e) {
69008       {
69009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69010       };
69011     } catch (...) {
69012       {
69013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69014       };
69015     }
69016   }
69017 }
69018
69019
69020 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69021   float jresult ;
69022   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69023   float result;
69024
69025   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69026   {
69027     try {
69028       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69029     } catch (std::out_of_range& e) {
69030       {
69031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69032       };
69033     } catch (std::exception& e) {
69034       {
69035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69036       };
69037     } catch (...) {
69038       {
69039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69040       };
69041     }
69042   }
69043   jresult = result;
69044   return jresult;
69045 }
69046
69047
69048 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollStartedSignal(void * jarg1) {
69049   void * jresult ;
69050   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69051   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69052
69053   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69054   {
69055     try {
69056       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69057     } catch (std::out_of_range& e) {
69058       {
69059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69060       };
69061     } catch (std::exception& e) {
69062       {
69063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69064       };
69065     } catch (...) {
69066       {
69067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69068       };
69069     }
69070   }
69071   jresult = (void *)result;
69072   return jresult;
69073 }
69074
69075
69076 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69077   void * jresult ;
69078   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69079   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69080
69081   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69082   {
69083     try {
69084       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69085     } catch (std::out_of_range& e) {
69086       {
69087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (std::exception& e) {
69090       {
69091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69092       };
69093     } catch (...) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69096       };
69097     }
69098   }
69099   jresult = (void *)result;
69100   return jresult;
69101 }
69102
69103
69104 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollCompletedSignal(void * jarg1) {
69105   void * jresult ;
69106   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69107   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69108
69109   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69110   {
69111     try {
69112       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69113     } catch (std::out_of_range& e) {
69114       {
69115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69116       };
69117     } catch (std::exception& e) {
69118       {
69119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69120       };
69121     } catch (...) {
69122       {
69123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69124       };
69125     }
69126   }
69127   jresult = (void *)result;
69128   return jresult;
69129 }
69130
69131
69132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_IsVertical(int jarg1) {
69133   unsigned int jresult ;
69134   Dali::Toolkit::ControlOrientation::Type arg1 ;
69135   bool result;
69136
69137   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69138   {
69139     try {
69140       result = (bool)Dali::Toolkit::IsVertical(arg1);
69141     } catch (std::out_of_range& e) {
69142       {
69143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (std::exception& e) {
69146       {
69147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69152       };
69153     }
69154   }
69155   jresult = result;
69156   return jresult;
69157 }
69158
69159
69160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_IsHorizontal(int jarg1) {
69161   unsigned int jresult ;
69162   Dali::Toolkit::ControlOrientation::Type arg1 ;
69163   bool result;
69164
69165   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69166   {
69167     try {
69168       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69169     } catch (std::out_of_range& e) {
69170       {
69171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69172       };
69173     } catch (std::exception& e) {
69174       {
69175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69176       };
69177     } catch (...) {
69178       {
69179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69180       };
69181     }
69182   }
69183   jresult = result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69189   void * jresult ;
69190   unsigned int arg1 ;
69191   unsigned int arg2 ;
69192   Dali::Toolkit::ItemRange *result = 0 ;
69193
69194   arg1 = (unsigned int)jarg1;
69195   arg2 = (unsigned int)jarg2;
69196   {
69197     try {
69198       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69199     } catch (std::out_of_range& e) {
69200       {
69201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69202       };
69203     } catch (std::exception& e) {
69204       {
69205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (...) {
69208       {
69209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69210       };
69211     }
69212   }
69213   jresult = (void *)result;
69214   return jresult;
69215 }
69216
69217
69218 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemRange__SWIG_1(void * jarg1) {
69219   void * jresult ;
69220   Dali::Toolkit::ItemRange *arg1 = 0 ;
69221   Dali::Toolkit::ItemRange *result = 0 ;
69222
69223   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69224   if (!arg1) {
69225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69226     return 0;
69227   }
69228   {
69229     try {
69230       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69231     } catch (std::out_of_range& e) {
69232       {
69233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69234       };
69235     } catch (std::exception& e) {
69236       {
69237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69238       };
69239     } catch (...) {
69240       {
69241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69242       };
69243     }
69244   }
69245   jresult = (void *)result;
69246   return jresult;
69247 }
69248
69249
69250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemRange_Assign(void * jarg1, void * jarg2) {
69251   void * jresult ;
69252   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69253   Dali::Toolkit::ItemRange *arg2 = 0 ;
69254   Dali::Toolkit::ItemRange *result = 0 ;
69255
69256   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69257   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69258   if (!arg2) {
69259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69260     return 0;
69261   }
69262   {
69263     try {
69264       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69265     } catch (std::out_of_range& e) {
69266       {
69267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69268       };
69269     } catch (std::exception& e) {
69270       {
69271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69272       };
69273     } catch (...) {
69274       {
69275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69276       };
69277     }
69278   }
69279   jresult = (void *)result;
69280   return jresult;
69281 }
69282
69283
69284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69285   unsigned int jresult ;
69286   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69287   unsigned int arg2 ;
69288   bool result;
69289
69290   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69291   arg2 = (unsigned int)jarg2;
69292   {
69293     try {
69294       result = (bool)(arg1)->Within(arg2);
69295     } catch (std::out_of_range& e) {
69296       {
69297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69298       };
69299     } catch (std::exception& e) {
69300       {
69301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69302       };
69303     } catch (...) {
69304       {
69305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69306       };
69307     }
69308   }
69309   jresult = result;
69310   return jresult;
69311 }
69312
69313
69314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemRange_Intersection(void * jarg1, void * jarg2) {
69315   void * jresult ;
69316   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69317   Dali::Toolkit::ItemRange *arg2 = 0 ;
69318   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69319
69320   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69321   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69322   if (!arg2) {
69323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69324     return 0;
69325   }
69326   {
69327     try {
69328       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69329     } catch (std::out_of_range& e) {
69330       {
69331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69332       };
69333     } catch (std::exception& e) {
69334       {
69335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69336       };
69337     } catch (...) {
69338       {
69339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69340       };
69341     }
69342   }
69343   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69344   return jresult;
69345 }
69346
69347
69348 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69349   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69350   unsigned int arg2 ;
69351
69352   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69353   arg2 = (unsigned int)jarg2;
69354   if (arg1) (arg1)->begin = arg2;
69355 }
69356
69357
69358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_begin_get(void * jarg1) {
69359   unsigned int jresult ;
69360   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69361   unsigned int result;
69362
69363   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69364   result = (unsigned int) ((arg1)->begin);
69365   jresult = result;
69366   return jresult;
69367 }
69368
69369
69370 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69371   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69372   unsigned int arg2 ;
69373
69374   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69375   arg2 = (unsigned int)jarg2;
69376   if (arg1) (arg1)->end = arg2;
69377 }
69378
69379
69380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_end_get(void * jarg1) {
69381   unsigned int jresult ;
69382   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69383   unsigned int result;
69384
69385   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69386   result = (unsigned int) ((arg1)->end);
69387   jresult = result;
69388   return jresult;
69389 }
69390
69391
69392 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemRange(void * jarg1) {
69393   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69394
69395   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69396   {
69397     try {
69398       delete arg1;
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69406       };
69407     } catch (...) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69410       };
69411     }
69412   }
69413 }
69414
69415
69416 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemLayout(void * jarg1) {
69417   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69418
69419   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69420   {
69421     try {
69422       delete arg1;
69423     } catch (std::out_of_range& e) {
69424       {
69425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69426       };
69427     } catch (std::exception& e) {
69428       {
69429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69430       };
69431     } catch (...) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69434       };
69435     }
69436   }
69437 }
69438
69439
69440 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69441   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69442   Dali::Toolkit::ControlOrientation::Type arg2 ;
69443
69444   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69445   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69446   {
69447     try {
69448       (arg1)->SetOrientation(arg2);
69449     } catch (std::out_of_range& e) {
69450       {
69451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69452       };
69453     } catch (std::exception& e) {
69454       {
69455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69456       };
69457     } catch (...) {
69458       {
69459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69460       };
69461     }
69462   }
69463 }
69464
69465
69466 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemLayout_GetOrientation(void * jarg1) {
69467   int jresult ;
69468   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69469   Dali::Toolkit::ControlOrientation::Type result;
69470
69471   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69472   {
69473     try {
69474       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69475     } catch (std::out_of_range& e) {
69476       {
69477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69478       };
69479     } catch (std::exception& e) {
69480       {
69481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69482       };
69483     } catch (...) {
69484       {
69485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69486       };
69487     }
69488   }
69489   jresult = (int)result;
69490   return jresult;
69491 }
69492
69493 /* this should be fixed after tizen branch being upgraded!
69494 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69495   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69496   Dali::Property::Map *arg2 = 0 ;
69497
69498   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69499   arg2 = (Dali::Property::Map *)jarg2;
69500   if (!arg2) {
69501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69502     return ;
69503   }
69504   {
69505     try {
69506       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69507     } catch (std::out_of_range& e) {
69508       {
69509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69510       };
69511     } catch (std::exception& e) {
69512       {
69513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69514       };
69515     } catch (...) {
69516       {
69517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69518       };
69519     }
69520   }
69521 }
69522
69523
69524 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetLayoutProperties(void * jarg1) {
69525   void * jresult ;
69526   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69527   Dali::Property::Map result;
69528
69529   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69530   {
69531     try {
69532       result = (arg1)->GetLayoutProperties();
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (...) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69544       };
69545     }
69546   }
69547   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69548   return jresult;
69549 }
69550
69551
69552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemLayout_HasLayoutChanged(void * jarg1) {
69553   unsigned int jresult ;
69554   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69555   bool result;
69556
69557   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69558   {
69559     try {
69560       result = (bool)(arg1)->HasLayoutChanged();
69561     } catch (std::out_of_range& e) {
69562       {
69563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69564       };
69565     } catch (std::exception& e) {
69566       {
69567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (...) {
69570       {
69571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69572       };
69573     }
69574   }
69575   jresult = result;
69576   return jresult;
69577 }
69578
69579
69580 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_ResetLayoutChangedFlag(void * jarg1) {
69581   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69582
69583   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69584   {
69585     try {
69586       (arg1)->ResetLayoutChangedFlag();
69587     } catch (std::out_of_range& e) {
69588       {
69589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69590       };
69591     } catch (std::exception& e) {
69592       {
69593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69594       };
69595     } catch (...) {
69596       {
69597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69598       };
69599     }
69600   }
69601 }
69602 */
69603
69604 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69605   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69606   unsigned int arg2 ;
69607   Dali::Vector3 *arg3 = 0 ;
69608   Dali::Vector3 *arg4 = 0 ;
69609
69610   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69611   arg2 = (unsigned int)jarg2;
69612   arg3 = (Dali::Vector3 *)jarg3;
69613   if (!arg3) {
69614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69615     return ;
69616   }
69617   arg4 = (Dali::Vector3 *)jarg4;
69618   if (!arg4) {
69619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69620     return ;
69621   }
69622   {
69623     try {
69624       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69625     } catch (std::out_of_range& e) {
69626       {
69627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69628       };
69629     } catch (std::exception& e) {
69630       {
69631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69632       };
69633     } catch (...) {
69634       {
69635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69636       };
69637     }
69638   }
69639 }
69640
69641
69642 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69643   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69644   Dali::Vector3 *arg2 = 0 ;
69645
69646   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69647   arg2 = (Dali::Vector3 *)jarg2;
69648   if (!arg2) {
69649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69650     return ;
69651   }
69652   {
69653     try {
69654       (arg1)->SetItemSize((Dali::Vector3 const &)*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 float SWIGSTDCALL CSharp_NUI_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69673   float jresult ;
69674   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69675   unsigned int arg2 ;
69676   Dali::Vector3 arg3 ;
69677   Dali::Vector3 *argp3 ;
69678   float result;
69679
69680   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69681   arg2 = (unsigned int)jarg2;
69682   argp3 = (Dali::Vector3 *)jarg3;
69683   if (!argp3) {
69684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69685     return 0;
69686   }
69687   arg3 = *argp3;
69688   {
69689     try {
69690       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69691     } catch (std::out_of_range& e) {
69692       {
69693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69694       };
69695     } catch (std::exception& e) {
69696       {
69697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69698       };
69699     } catch (...) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69702       };
69703     }
69704   }
69705   jresult = result;
69706   return jresult;
69707 }
69708
69709
69710 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69711   float jresult ;
69712   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69713   float arg2 ;
69714   float result;
69715
69716   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69717   arg2 = (float)jarg2;
69718   {
69719     try {
69720       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69721     } catch (std::out_of_range& e) {
69722       {
69723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69724       };
69725     } catch (std::exception& e) {
69726       {
69727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69728       };
69729     } catch (...) {
69730       {
69731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69732       };
69733     }
69734   }
69735   jresult = result;
69736   return jresult;
69737 }
69738
69739
69740 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69741   float jresult ;
69742   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69743   unsigned int arg2 ;
69744   float result;
69745
69746   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69747   arg2 = (unsigned int)jarg2;
69748   {
69749     try {
69750       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69751     } catch (std::out_of_range& e) {
69752       {
69753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69754       };
69755     } catch (std::exception& e) {
69756       {
69757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69762       };
69763     }
69764   }
69765   jresult = result;
69766   return jresult;
69767 }
69768
69769
69770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69771   void * jresult ;
69772   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69773   float arg2 ;
69774   Dali::Vector3 arg3 ;
69775   Dali::Vector3 *argp3 ;
69776   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69777
69778   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69779   arg2 = (float)jarg2;
69780   argp3 = (Dali::Vector3 *)jarg3;
69781   if (!argp3) {
69782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69783     return 0;
69784   }
69785   arg3 = *argp3;
69786   {
69787     try {
69788       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69789     } catch (std::out_of_range& e) {
69790       {
69791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69792       };
69793     } catch (std::exception& e) {
69794       {
69795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69796       };
69797     } catch (...) {
69798       {
69799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69800       };
69801     }
69802   }
69803   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69804   return jresult;
69805 }
69806
69807
69808 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69809   float jresult ;
69810   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69811   int arg2 ;
69812   float arg3 ;
69813   Dali::Vector3 *arg4 = 0 ;
69814   float result;
69815
69816   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69817   arg2 = (int)jarg2;
69818   arg3 = (float)jarg3;
69819   arg4 = (Dali::Vector3 *)jarg4;
69820   if (!arg4) {
69821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69822     return 0;
69823   }
69824   {
69825     try {
69826       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69827     } catch (std::out_of_range& e) {
69828       {
69829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (std::exception& e) {
69832       {
69833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (...) {
69836       {
69837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69838       };
69839     }
69840   }
69841   jresult = result;
69842   return jresult;
69843 }
69844
69845
69846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69847   unsigned int jresult ;
69848   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69849   Dali::Vector3 arg2 ;
69850   Dali::Vector3 *argp2 ;
69851   unsigned int result;
69852
69853   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69854   argp2 = (Dali::Vector3 *)jarg2;
69855   if (!argp2) {
69856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69857     return 0;
69858   }
69859   arg2 = *argp2;
69860   {
69861     try {
69862       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69863     } catch (std::out_of_range& e) {
69864       {
69865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69866       };
69867     } catch (std::exception& e) {
69868       {
69869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69870       };
69871     } catch (...) {
69872       {
69873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69874       };
69875     }
69876   }
69877   jresult = result;
69878   return jresult;
69879 }
69880
69881
69882 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69883   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69884   unsigned int arg2 ;
69885   Dali::Vector3 *arg3 = 0 ;
69886   Dali::Vector3 *arg4 = 0 ;
69887
69888   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69889   arg2 = (unsigned int)jarg2;
69890   arg3 = (Dali::Vector3 *)jarg3;
69891   if (!arg3) {
69892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69893     return ;
69894   }
69895   arg4 = (Dali::Vector3 *)jarg4;
69896   if (!arg4) {
69897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69898     return ;
69899   }
69900   {
69901     try {
69902       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69903     } catch (std::out_of_range& e) {
69904       {
69905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69906       };
69907     } catch (std::exception& e) {
69908       {
69909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69910       };
69911     } catch (...) {
69912       {
69913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69914       };
69915     }
69916   }
69917 }
69918
69919
69920 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetScrollDirection(void * jarg1) {
69921   void * jresult ;
69922   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69923   Dali::Degree result;
69924
69925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69926   {
69927     try {
69928       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69929     } catch (std::out_of_range& e) {
69930       {
69931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69932       };
69933     } catch (std::exception& e) {
69934       {
69935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69936       };
69937     } catch (...) {
69938       {
69939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69940       };
69941     }
69942   }
69943   jresult = new Dali::Degree((const Dali::Degree &)result);
69944   return jresult;
69945 }
69946
69947
69948 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69949   float jresult ;
69950   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69951   float result;
69952
69953   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69954   {
69955     try {
69956       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69957     } catch (std::out_of_range& e) {
69958       {
69959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69960       };
69961     } catch (std::exception& e) {
69962       {
69963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69964       };
69965     } catch (...) {
69966       {
69967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69968       };
69969     }
69970   }
69971   jresult = result;
69972   return jresult;
69973 }
69974
69975
69976 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69977   float jresult ;
69978   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69979   float result;
69980
69981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69982   {
69983     try {
69984       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69985     } catch (std::out_of_range& e) {
69986       {
69987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (std::exception& e) {
69990       {
69991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69996       };
69997     }
69998   }
69999   jresult = result;
70000   return jresult;
70001 }
70002
70003
70004 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70005   float jresult ;
70006   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70007   float result;
70008
70009   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70010   {
70011     try {
70012       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70013     } catch (std::out_of_range& e) {
70014       {
70015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (std::exception& e) {
70018       {
70019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027   jresult = result;
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70033   int jresult ;
70034   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70035   int arg2 ;
70036   int arg3 ;
70037   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70038   bool arg5 ;
70039   int result;
70040
70041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70042   arg2 = (int)jarg2;
70043   arg3 = (int)jarg3;
70044   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70045   arg5 = jarg5 ? true : false;
70046   {
70047     try {
70048       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70060       };
70061     }
70062   }
70063   jresult = result;
70064   return jresult;
70065 }
70066
70067
70068 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70069   float jresult ;
70070   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70071   float result;
70072
70073   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70074   {
70075     try {
70076       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (...) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70088       };
70089     }
70090   }
70091   jresult = result;
70092   return jresult;
70093 }
70094
70095
70096 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70097   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70098   Dali::Actor *arg2 = 0 ;
70099   int arg3 ;
70100   Dali::Vector3 *arg4 = 0 ;
70101   Dali::Actor *arg5 = 0 ;
70102
70103   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70104   arg2 = (Dali::Actor *)jarg2;
70105   if (!arg2) {
70106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70107     return ;
70108   }
70109   arg3 = (int)jarg3;
70110   arg4 = (Dali::Vector3 *)jarg4;
70111   if (!arg4) {
70112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70113     return ;
70114   }
70115   arg5 = (Dali::Actor *)jarg5;
70116   if (!arg5) {
70117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70118     return ;
70119   }
70120   {
70121     try {
70122       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70123     } catch (std::out_of_range& e) {
70124       {
70125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70126       };
70127     } catch (std::exception& e) {
70128       {
70129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70130       };
70131     } catch (...) {
70132       {
70133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70134       };
70135     }
70136   }
70137 }
70138
70139
70140 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70141   void * jresult ;
70142   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70143   int arg2 ;
70144   float arg3 ;
70145   Dali::Vector3 *arg4 = 0 ;
70146   Dali::Vector3 result;
70147
70148   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70149   arg2 = (int)jarg2;
70150   arg3 = (float)jarg3;
70151   arg4 = (Dali::Vector3 *)jarg4;
70152   if (!arg4) {
70153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70154     return 0;
70155   }
70156   {
70157     try {
70158       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70159     } catch (std::out_of_range& e) {
70160       {
70161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70162       };
70163     } catch (std::exception& e) {
70164       {
70165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70170       };
70171     }
70172   }
70173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70174   return jresult;
70175 }
70176
70177
70178 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NewItemLayout(int jarg1) {
70179   void * jresult ;
70180   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70181   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70182
70183   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70184   {
70185     try {
70186       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70187     } catch (std::out_of_range& e) {
70188       {
70189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (std::exception& e) {
70192       {
70193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70194       };
70195     } catch (...) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70198       };
70199     }
70200   }
70201   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70202   return jresult;
70203 }
70204
70205
70206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemFactory(void * jarg1) {
70207   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70208
70209   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70210   {
70211     try {
70212       delete arg1;
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70220       };
70221     } catch (...) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70224       };
70225     }
70226   }
70227 }
70228
70229
70230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemFactory_GetNumberOfItems(void * jarg1) {
70231   unsigned int jresult ;
70232   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70233   unsigned int result;
70234
70235   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70236   {
70237     try {
70238       result = (unsigned int)(arg1)->GetNumberOfItems();
70239     } catch (std::out_of_range& e) {
70240       {
70241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70242       };
70243     } catch (std::exception& e) {
70244       {
70245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70246       };
70247     } catch (...) {
70248       {
70249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70250       };
70251     }
70252   }
70253   jresult = result;
70254   return jresult;
70255 }
70256
70257
70258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70259   void * jresult ;
70260   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70261   unsigned int arg2 ;
70262   Dali::Actor result;
70263
70264   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70265   arg2 = (unsigned int)jarg2;
70266   {
70267     try {
70268       result = (arg1)->NewItem(arg2);
70269     } catch (std::out_of_range& e) {
70270       {
70271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70272       };
70273     } catch (std::exception& e) {
70274       {
70275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (...) {
70278       {
70279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70280       };
70281     }
70282   }
70283   jresult = new Dali::Actor((const Dali::Actor &)result);
70284   return jresult;
70285 }
70286
70287
70288 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70289   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70290   unsigned int arg2 ;
70291   Dali::Actor arg3 ;
70292   Dali::Actor *argp3 ;
70293
70294   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70295   arg2 = (unsigned int)jarg2;
70296   argp3 = (Dali::Actor *)jarg3;
70297   if (!argp3) {
70298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70299     return ;
70300   }
70301   arg3 = *argp3;
70302   {
70303     try {
70304       (arg1)->ItemReleased(arg2,arg3);
70305     } catch (std::out_of_range& e) {
70306       {
70307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70308       };
70309     } catch (std::exception& e) {
70310       {
70311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70312       };
70313     } catch (...) {
70314       {
70315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70316       };
70317     }
70318   }
70319 }
70320
70321
70322 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70323   int jresult ;
70324   int result;
70325
70326   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70327   jresult = (int)result;
70328   return jresult;
70329 }
70330
70331
70332 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70333   int jresult ;
70334   int result;
70335
70336   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70337   jresult = (int)result;
70338   return jresult;
70339 }
70340
70341
70342 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70343   int jresult ;
70344   int result;
70345
70346   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70347   jresult = (int)result;
70348   return jresult;
70349 }
70350
70351
70352 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70353   int jresult ;
70354   int result;
70355
70356   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70357   jresult = (int)result;
70358   return jresult;
70359 }
70360
70361
70362 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_REFRESH_INTERVAL_get() {
70363   int jresult ;
70364   int result;
70365
70366   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70367   jresult = (int)result;
70368   return jresult;
70369 }
70370
70371
70372 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_LAYOUT_POSITION_get() {
70373   int jresult ;
70374   int result;
70375
70376   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70377   jresult = (int)result;
70378   return jresult;
70379 }
70380
70381
70382 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_SPEED_get() {
70383   int jresult ;
70384   int result;
70385
70386   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70387   jresult = (int)result;
70388   return jresult;
70389 }
70390
70391
70392 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_OVERSHOOT_get() {
70393   int jresult ;
70394   int result;
70395
70396   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70397   jresult = (int)result;
70398   return jresult;
70399 }
70400
70401
70402 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_DIRECTION_get() {
70403   int jresult ;
70404   int result;
70405
70406   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70407   jresult = (int)result;
70408   return jresult;
70409 }
70410
70411
70412 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_LAYOUT_ORIENTATION_get() {
70413   int jresult ;
70414   int result;
70415
70416   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70417   jresult = (int)result;
70418   return jresult;
70419 }
70420
70421
70422 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70423   int jresult ;
70424   int result;
70425
70426   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70427   jresult = (int)result;
70428   return jresult;
70429 }
70430
70431
70432 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView_Property() {
70433   void * jresult ;
70434   Dali::Toolkit::ItemView::Property *result = 0 ;
70435
70436   {
70437     try {
70438       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70439     } catch (std::out_of_range& e) {
70440       {
70441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70442       };
70443     } catch (std::exception& e) {
70444       {
70445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70446       };
70447     } catch (...) {
70448       {
70449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70450       };
70451     }
70452   }
70453   jresult = (void *)result;
70454   return jresult;
70455 }
70456
70457
70458 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemView_Property(void * jarg1) {
70459   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70460
70461   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70462   {
70463     try {
70464       delete arg1;
70465     } catch (std::out_of_range& e) {
70466       {
70467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70468       };
70469     } catch (std::exception& e) {
70470       {
70471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70472       };
70473     } catch (...) {
70474       {
70475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70476       };
70477     }
70478   }
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView__SWIG_0() {
70483   void * jresult ;
70484   Dali::Toolkit::ItemView *result = 0 ;
70485
70486   {
70487     try {
70488       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70489     } catch (std::out_of_range& e) {
70490       {
70491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70492       };
70493     } catch (std::exception& e) {
70494       {
70495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70496       };
70497     } catch (...) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70500       };
70501     }
70502   }
70503   jresult = (void *)result;
70504   return jresult;
70505 }
70506
70507
70508 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView__SWIG_1(void * jarg1) {
70509   void * jresult ;
70510   Dali::Toolkit::ItemView *arg1 = 0 ;
70511   Dali::Toolkit::ItemView *result = 0 ;
70512
70513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70514   if (!arg1) {
70515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70516     return 0;
70517   }
70518   {
70519     try {
70520       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70521     } catch (std::out_of_range& e) {
70522       {
70523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (std::exception& e) {
70526       {
70527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70528       };
70529     } catch (...) {
70530       {
70531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70532       };
70533     }
70534   }
70535   jresult = (void *)result;
70536   return jresult;
70537 }
70538
70539
70540 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_Assign(void * jarg1, void * jarg2) {
70541   void * jresult ;
70542   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70543   Dali::Toolkit::ItemView *arg2 = 0 ;
70544   Dali::Toolkit::ItemView *result = 0 ;
70545
70546   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70547   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70548   if (!arg2) {
70549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70550     return 0;
70551   }
70552   {
70553     try {
70554       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70555     } catch (std::out_of_range& e) {
70556       {
70557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70558       };
70559     } catch (std::exception& e) {
70560       {
70561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70562       };
70563     } catch (...) {
70564       {
70565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70566       };
70567     }
70568   }
70569   jresult = (void *)result;
70570   return jresult;
70571 }
70572
70573
70574 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemView(void * jarg1) {
70575   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70576
70577   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70578   {
70579     try {
70580       delete arg1;
70581     } catch (std::out_of_range& e) {
70582       {
70583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70584       };
70585     } catch (std::exception& e) {
70586       {
70587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70588       };
70589     } catch (...) {
70590       {
70591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70592       };
70593     }
70594   }
70595 }
70596
70597
70598 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_New(void * jarg1) {
70599   void * jresult ;
70600   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70601   Dali::Toolkit::ItemView result;
70602
70603   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70604   if (!arg1) {
70605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70606     return 0;
70607   }
70608   {
70609     try {
70610       result = Dali::Toolkit::ItemView::New(*arg1);
70611     } catch (std::out_of_range& e) {
70612       {
70613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70614       };
70615     } catch (std::exception& e) {
70616       {
70617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70618       };
70619     } catch (...) {
70620       {
70621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70622       };
70623     }
70624   }
70625   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70626   return jresult;
70627 }
70628
70629
70630 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_DownCast(void * jarg1) {
70631   void * jresult ;
70632   Dali::BaseHandle arg1 ;
70633   Dali::BaseHandle *argp1 ;
70634   Dali::Toolkit::ItemView result;
70635
70636   argp1 = (Dali::BaseHandle *)jarg1;
70637   if (!argp1) {
70638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70639     return 0;
70640   }
70641   arg1 = *argp1;
70642   {
70643     try {
70644       result = Dali::Toolkit::ItemView::DownCast(arg1);
70645     } catch (std::out_of_range& e) {
70646       {
70647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70648       };
70649     } catch (std::exception& e) {
70650       {
70651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70652       };
70653     } catch (...) {
70654       {
70655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70656       };
70657     }
70658   }
70659   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70660   return jresult;
70661 }
70662
70663
70664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetLayoutCount(void * jarg1) {
70665   unsigned int jresult ;
70666   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70667   unsigned int result;
70668
70669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70670   {
70671     try {
70672       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70673     } catch (std::out_of_range& e) {
70674       {
70675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70676       };
70677     } catch (std::exception& e) {
70678       {
70679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70680       };
70681     } catch (...) {
70682       {
70683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70684       };
70685     }
70686   }
70687   jresult = result;
70688   return jresult;
70689 }
70690
70691
70692 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_AddLayout(void * jarg1, void * jarg2) {
70693   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70694   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70695
70696   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70697   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70698   if (!arg2) {
70699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70700     return ;
70701   }
70702   {
70703     try {
70704       (arg1)->AddLayout(*arg2);
70705     } catch (std::out_of_range& e) {
70706       {
70707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70708       };
70709     } catch (std::exception& e) {
70710       {
70711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70712       };
70713     } catch (...) {
70714       {
70715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70716       };
70717     }
70718   }
70719 }
70720
70721
70722 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70724   unsigned int arg2 ;
70725
70726   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70727   arg2 = (unsigned int)jarg2;
70728   {
70729     try {
70730       (arg1)->RemoveLayout(arg2);
70731     } catch (std::out_of_range& e) {
70732       {
70733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70734       };
70735     } catch (std::exception& e) {
70736       {
70737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70738       };
70739     } catch (...) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70742       };
70743     }
70744   }
70745 }
70746
70747
70748 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70749   void * jresult ;
70750   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70751   unsigned int arg2 ;
70752   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70753
70754   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70755   arg2 = (unsigned int)jarg2;
70756   {
70757     try {
70758       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70759     } catch (std::out_of_range& e) {
70760       {
70761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70762       };
70763     } catch (std::exception& e) {
70764       {
70765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70766       };
70767     } catch (...) {
70768       {
70769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70770       };
70771     }
70772   }
70773   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70774   return jresult;
70775 }
70776
70777
70778 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetActiveLayout(void * jarg1) {
70779   void * jresult ;
70780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70781   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70782
70783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70784   {
70785     try {
70786       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70787     } catch (std::out_of_range& e) {
70788       {
70789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70790       };
70791     } catch (std::exception& e) {
70792       {
70793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70794       };
70795     } catch (...) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70798       };
70799     }
70800   }
70801   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70802   return jresult;
70803 }
70804
70805
70806 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70807   float jresult ;
70808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70809   Dali::Toolkit::ItemId arg2 ;
70810   float result;
70811
70812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70813   arg2 = (Dali::Toolkit::ItemId)jarg2;
70814   {
70815     try {
70816       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70817     } catch (std::out_of_range& e) {
70818       {
70819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70820       };
70821     } catch (std::exception& e) {
70822       {
70823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70824       };
70825     } catch (...) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70828       };
70829     }
70830   }
70831   jresult = result;
70832   return jresult;
70833 }
70834
70835
70836 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70837   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70838   unsigned int arg2 ;
70839   Dali::Vector3 arg3 ;
70840   float arg4 ;
70841   Dali::Vector3 *argp3 ;
70842
70843   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70844   arg2 = (unsigned int)jarg2;
70845   argp3 = (Dali::Vector3 *)jarg3;
70846   if (!argp3) {
70847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70848     return ;
70849   }
70850   arg3 = *argp3;
70851   arg4 = (float)jarg4;
70852   {
70853     try {
70854       (arg1)->ActivateLayout(arg2,arg3,arg4);
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70862       };
70863     } catch (...) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70866       };
70867     }
70868   }
70869 }
70870
70871
70872 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_DeactivateCurrentLayout(void * jarg1) {
70873   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70874
70875   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70876   {
70877     try {
70878       (arg1)->DeactivateCurrentLayout();
70879     } catch (std::out_of_range& e) {
70880       {
70881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70882       };
70883     } catch (std::exception& e) {
70884       {
70885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70890       };
70891     }
70892   }
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70898   float arg2 ;
70899
70900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70901   arg2 = (float)jarg2;
70902   {
70903     try {
70904       (arg1)->SetMinimumSwipeSpeed(arg2);
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (...) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70916       };
70917     }
70918   }
70919 }
70920
70921
70922 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70923   float jresult ;
70924   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70925   float result;
70926
70927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70928   {
70929     try {
70930       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (...) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70942       };
70943     }
70944   }
70945   jresult = result;
70946   return jresult;
70947 }
70948
70949
70950 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70952   float arg2 ;
70953
70954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70955   arg2 = (float)jarg2;
70956   {
70957     try {
70958       (arg1)->SetMinimumSwipeDistance(arg2);
70959     } catch (std::out_of_range& e) {
70960       {
70961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70962       };
70963     } catch (std::exception& e) {
70964       {
70965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70966       };
70967     } catch (...) {
70968       {
70969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70970       };
70971     }
70972   }
70973 }
70974
70975
70976 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70977   float jresult ;
70978   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70979   float result;
70980
70981   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70982   {
70983     try {
70984       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70985     } catch (std::out_of_range& e) {
70986       {
70987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70988       };
70989     } catch (std::exception& e) {
70990       {
70991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70992       };
70993     } catch (...) {
70994       {
70995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70996       };
70997     }
70998   }
70999   jresult = result;
71000   return jresult;
71001 }
71002
71003
71004 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71005   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71006   float arg2 ;
71007
71008   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71009   arg2 = (float)jarg2;
71010   {
71011     try {
71012       (arg1)->SetWheelScrollDistanceStep(arg2);
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71020       };
71021     } catch (...) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71024       };
71025     }
71026   }
71027 }
71028
71029
71030 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71031   float jresult ;
71032   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71033   float result;
71034
71035   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71036   {
71037     try {
71038       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71039     } catch (std::out_of_range& e) {
71040       {
71041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71042       };
71043     } catch (std::exception& e) {
71044       {
71045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71046       };
71047     } catch (...) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71050       };
71051     }
71052   }
71053   jresult = result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71060   bool arg2 ;
71061
71062   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71063   arg2 = jarg2 ? true : false;
71064   {
71065     try {
71066       (arg1)->SetAnchoring(arg2);
71067     } catch (std::out_of_range& e) {
71068       {
71069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71070       };
71071     } catch (std::exception& e) {
71072       {
71073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71074       };
71075     } catch (...) {
71076       {
71077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71078       };
71079     }
71080   }
71081 }
71082
71083
71084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetAnchoring(void * jarg1) {
71085   unsigned int jresult ;
71086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71087   bool result;
71088
71089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71090   {
71091     try {
71092       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71093     } catch (std::out_of_range& e) {
71094       {
71095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71096       };
71097     } catch (std::exception& e) {
71098       {
71099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71100       };
71101     } catch (...) {
71102       {
71103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71104       };
71105     }
71106   }
71107   jresult = result;
71108   return jresult;
71109 }
71110
71111
71112 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71114   float arg2 ;
71115
71116   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71117   arg2 = (float)jarg2;
71118   {
71119     try {
71120       (arg1)->SetAnchoringDuration(arg2);
71121     } catch (std::out_of_range& e) {
71122       {
71123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71124       };
71125     } catch (std::exception& e) {
71126       {
71127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71128       };
71129     } catch (...) {
71130       {
71131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71132       };
71133     }
71134   }
71135 }
71136
71137
71138 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetAnchoringDuration(void * jarg1) {
71139   float jresult ;
71140   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71141   float result;
71142
71143   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71144   {
71145     try {
71146       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71147     } catch (std::out_of_range& e) {
71148       {
71149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71150       };
71151     } catch (std::exception& e) {
71152       {
71153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71154       };
71155     } catch (...) {
71156       {
71157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71158       };
71159     }
71160   }
71161   jresult = result;
71162   return jresult;
71163 }
71164
71165
71166 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71168   Dali::Toolkit::ItemId arg2 ;
71169   float arg3 ;
71170
71171   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71172   arg2 = (Dali::Toolkit::ItemId)jarg2;
71173   arg3 = (float)jarg3;
71174   {
71175     try {
71176       (arg1)->ScrollToItem(arg2,arg3);
71177     } catch (std::out_of_range& e) {
71178       {
71179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71180       };
71181     } catch (std::exception& e) {
71182       {
71183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71184       };
71185     } catch (...) {
71186       {
71187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71188       };
71189     }
71190   }
71191 }
71192
71193
71194 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71195   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71196   float arg2 ;
71197
71198   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71199   arg2 = (float)jarg2;
71200   {
71201     try {
71202       (arg1)->SetRefreshInterval(arg2);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71210       };
71211     } catch (...) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71214       };
71215     }
71216   }
71217 }
71218
71219
71220 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetRefreshInterval(void * jarg1) {
71221   float jresult ;
71222   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71223   float result;
71224
71225   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71226   {
71227     try {
71228       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71229     } catch (std::out_of_range& e) {
71230       {
71231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71232       };
71233     } catch (std::exception& e) {
71234       {
71235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71236       };
71237     } catch (...) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71240       };
71241     }
71242   }
71243   jresult = result;
71244   return jresult;
71245 }
71246
71247
71248 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_Refresh(void * jarg1) {
71249   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71250
71251   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71252   {
71253     try {
71254       (arg1)->Refresh();
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71262       };
71263     } catch (...) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71266       };
71267     }
71268   }
71269 }
71270
71271
71272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71273   void * jresult ;
71274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71275   Dali::Toolkit::ItemId arg2 ;
71276   Dali::Actor result;
71277
71278   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71279   arg2 = (Dali::Toolkit::ItemId)jarg2;
71280   {
71281     try {
71282       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71283     } catch (std::out_of_range& e) {
71284       {
71285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71286       };
71287     } catch (std::exception& e) {
71288       {
71289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71290       };
71291     } catch (...) {
71292       {
71293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71294       };
71295     }
71296   }
71297   jresult = new Dali::Actor((const Dali::Actor &)result);
71298   return jresult;
71299 }
71300
71301
71302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetItemId(void * jarg1, void * jarg2) {
71303   unsigned int jresult ;
71304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71305   Dali::Actor arg2 ;
71306   Dali::Actor *argp2 ;
71307   Dali::Toolkit::ItemId result;
71308
71309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71310   argp2 = (Dali::Actor *)jarg2;
71311   if (!argp2) {
71312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71313     return 0;
71314   }
71315   arg2 = *argp2;
71316   {
71317     try {
71318       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71319     } catch (std::out_of_range& e) {
71320       {
71321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71322       };
71323     } catch (std::exception& e) {
71324       {
71325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71326       };
71327     } catch (...) {
71328       {
71329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71330       };
71331     }
71332   }
71333   jresult = result;
71334   return jresult;
71335 }
71336
71337
71338 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71339   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71340   Dali::Toolkit::Item arg2 ;
71341   float arg3 ;
71342   Dali::Toolkit::Item *argp2 ;
71343
71344   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71345   argp2 = (Dali::Toolkit::Item *)jarg2;
71346   if (!argp2) {
71347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71348     return ;
71349   }
71350   arg2 = *argp2;
71351   arg3 = (float)jarg3;
71352   {
71353     try {
71354       (arg1)->InsertItem(arg2,arg3);
71355     } catch (std::out_of_range& e) {
71356       {
71357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71358       };
71359     } catch (std::exception& e) {
71360       {
71361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71362       };
71363     } catch (...) {
71364       {
71365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71366       };
71367     }
71368   }
71369 }
71370
71371
71372 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71373   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71374   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71375   float arg3 ;
71376
71377   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71378   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71379   if (!arg2) {
71380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71381     return ;
71382   }
71383   arg3 = (float)jarg3;
71384   {
71385     try {
71386       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71387     } catch (std::out_of_range& e) {
71388       {
71389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71390       };
71391     } catch (std::exception& e) {
71392       {
71393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71394       };
71395     } catch (...) {
71396       {
71397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71398       };
71399     }
71400   }
71401 }
71402
71403
71404 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71405   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71406   Dali::Toolkit::ItemId arg2 ;
71407   float arg3 ;
71408
71409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71410   arg2 = (Dali::Toolkit::ItemId)jarg2;
71411   arg3 = (float)jarg3;
71412   {
71413     try {
71414       (arg1)->RemoveItem(arg2,arg3);
71415     } catch (std::out_of_range& e) {
71416       {
71417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71418       };
71419     } catch (std::exception& e) {
71420       {
71421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71422       };
71423     } catch (...) {
71424       {
71425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71426       };
71427     }
71428   }
71429 }
71430
71431
71432 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71433   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71434   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71435   float arg3 ;
71436
71437   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71438   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71439   if (!arg2) {
71440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71441     return ;
71442   }
71443   arg3 = (float)jarg3;
71444   {
71445     try {
71446       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71447     } catch (std::out_of_range& e) {
71448       {
71449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71450       };
71451     } catch (std::exception& e) {
71452       {
71453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71454       };
71455     } catch (...) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71458       };
71459     }
71460   }
71461 }
71462
71463
71464 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71465   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71466   Dali::Toolkit::Item arg2 ;
71467   float arg3 ;
71468   Dali::Toolkit::Item *argp2 ;
71469
71470   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71471   argp2 = (Dali::Toolkit::Item *)jarg2;
71472   if (!argp2) {
71473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71474     return ;
71475   }
71476   arg2 = *argp2;
71477   arg3 = (float)jarg3;
71478   {
71479     try {
71480       (arg1)->ReplaceItem(arg2,arg3);
71481     } catch (std::out_of_range& e) {
71482       {
71483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71484       };
71485     } catch (std::exception& e) {
71486       {
71487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71488       };
71489     } catch (...) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71492       };
71493     }
71494   }
71495 }
71496
71497
71498 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71499   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71500   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71501   float arg3 ;
71502
71503   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71504   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71505   if (!arg2) {
71506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71507     return ;
71508   }
71509   arg3 = (float)jarg3;
71510   {
71511     try {
71512       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71513     } catch (std::out_of_range& e) {
71514       {
71515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71516       };
71517     } catch (std::exception& e) {
71518       {
71519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71520       };
71521     } catch (...) {
71522       {
71523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71524       };
71525     }
71526   }
71527 }
71528
71529
71530 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71531   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71532   Dali::Vector3 *arg2 = 0 ;
71533
71534   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71535   arg2 = (Dali::Vector3 *)jarg2;
71536   if (!arg2) {
71537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71538     return ;
71539   }
71540   {
71541     try {
71542       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71543     } catch (std::out_of_range& e) {
71544       {
71545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71546       };
71547     } catch (std::exception& e) {
71548       {
71549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71550       };
71551     } catch (...) {
71552       {
71553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71554       };
71555     }
71556   }
71557 }
71558
71559
71560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItemsParentOrigin(void * jarg1) {
71561   void * jresult ;
71562   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71563   Dali::Vector3 result;
71564
71565   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71566   {
71567     try {
71568       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71569     } catch (std::out_of_range& e) {
71570       {
71571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71572       };
71573     } catch (std::exception& e) {
71574       {
71575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71576       };
71577     } catch (...) {
71578       {
71579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71580       };
71581     }
71582   }
71583   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71584   return jresult;
71585 }
71586
71587
71588 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71589   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71590   Dali::Vector3 *arg2 = 0 ;
71591
71592   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71593   arg2 = (Dali::Vector3 *)jarg2;
71594   if (!arg2) {
71595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71596     return ;
71597   }
71598   {
71599     try {
71600       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71601     } catch (std::out_of_range& e) {
71602       {
71603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71604       };
71605     } catch (std::exception& e) {
71606       {
71607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71608       };
71609     } catch (...) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71612       };
71613     }
71614   }
71615 }
71616
71617
71618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItemsAnchorPoint(void * jarg1) {
71619   void * jresult ;
71620   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71621   Dali::Vector3 result;
71622
71623   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71624   {
71625     try {
71626       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71627     } catch (std::out_of_range& e) {
71628       {
71629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71630       };
71631     } catch (std::exception& e) {
71632       {
71633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (...) {
71636       {
71637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71638       };
71639     }
71640   }
71641   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71642   return jresult;
71643 }
71644
71645
71646 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71647   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71648   Dali::Toolkit::ItemRange *arg2 = 0 ;
71649
71650   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71651   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71652   if (!arg2) {
71653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71654     return ;
71655   }
71656   {
71657     try {
71658       (arg1)->GetItemsRange(*arg2);
71659     } catch (std::out_of_range& e) {
71660       {
71661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71662       };
71663     } catch (std::exception& e) {
71664       {
71665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71666       };
71667     } catch (...) {
71668       {
71669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71670       };
71671     }
71672   }
71673 }
71674
71675
71676 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_LayoutActivatedSignal(void * jarg1) {
71677   void * jresult ;
71678   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71679   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71680
71681   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71682   {
71683     try {
71684       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71685     } catch (std::out_of_range& e) {
71686       {
71687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (std::exception& e) {
71690       {
71691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71692       };
71693     } catch (...) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71696       };
71697     }
71698   }
71699   jresult = (void *)result;
71700   return jresult;
71701 }
71702
71703
71704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_MoveActorConstraint(void * jarg1, void * jarg2) {
71705   Dali::Vector3 *arg1 = 0 ;
71706   PropertyInputContainer *arg2 = 0 ;
71707
71708   arg1 = (Dali::Vector3 *)jarg1;
71709   if (!arg1) {
71710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71711     return ;
71712   }
71713   arg2 = (PropertyInputContainer *)jarg2;
71714   if (!arg2) {
71715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71716     return ;
71717   }
71718   {
71719     try {
71720       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71721     } catch (std::out_of_range& e) {
71722       {
71723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71724       };
71725     } catch (std::exception& e) {
71726       {
71727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71728       };
71729     } catch (...) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71732       };
71733     }
71734   }
71735 }
71736
71737
71738 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WrapActorConstraint(void * jarg1, void * jarg2) {
71739   Dali::Vector3 *arg1 = 0 ;
71740   PropertyInputContainer *arg2 = 0 ;
71741
71742   arg1 = (Dali::Vector3 *)jarg1;
71743   if (!arg1) {
71744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71745     return ;
71746   }
71747   arg2 = (PropertyInputContainer *)jarg2;
71748   if (!arg2) {
71749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71750     return ;
71751   }
71752   {
71753     try {
71754       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71755     } catch (std::out_of_range& e) {
71756       {
71757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71758       };
71759     } catch (std::exception& e) {
71760       {
71761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71762       };
71763     } catch (...) {
71764       {
71765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71766       };
71767     }
71768   }
71769 }
71770
71771
71772 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewEffect() {
71773   void * jresult ;
71774   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71775
71776   {
71777     try {
71778       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71779     } catch (std::out_of_range& e) {
71780       {
71781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71782       };
71783     } catch (std::exception& e) {
71784       {
71785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71786       };
71787     } catch (...) {
71788       {
71789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71790       };
71791     }
71792   }
71793   jresult = (void *)result;
71794   return jresult;
71795 }
71796
71797
71798 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewEffect(void * jarg1) {
71799   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71800
71801   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71802   {
71803     try {
71804       delete arg1;
71805     } catch (std::out_of_range& e) {
71806       {
71807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71808       };
71809     } catch (std::exception& e) {
71810       {
71811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71812       };
71813     } catch (...) {
71814       {
71815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71816       };
71817     }
71818   }
71819 }
71820
71821
71822 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71823   void * jresult ;
71824   Dali::Path arg1 ;
71825   Dali::Vector3 *arg2 = 0 ;
71826   Dali::Property::Index arg3 ;
71827   Dali::Vector3 *arg4 = 0 ;
71828   unsigned int arg5 ;
71829   Dali::Path *argp1 ;
71830   Dali::Toolkit::ScrollViewPagePathEffect result;
71831
71832   argp1 = (Dali::Path *)jarg1;
71833   if (!argp1) {
71834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71835     return 0;
71836   }
71837   arg1 = *argp1;
71838   arg2 = (Dali::Vector3 *)jarg2;
71839   if (!arg2) {
71840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71841     return 0;
71842   }
71843   arg3 = (Dali::Property::Index)jarg3;
71844   arg4 = (Dali::Vector3 *)jarg4;
71845   if (!arg4) {
71846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71847     return 0;
71848   }
71849   arg5 = (unsigned int)jarg5;
71850   {
71851     try {
71852       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71853     } catch (std::out_of_range& e) {
71854       {
71855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71856       };
71857     } catch (std::exception& e) {
71858       {
71859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71860       };
71861     } catch (...) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71864       };
71865     }
71866   }
71867   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71868   return jresult;
71869 }
71870
71871
71872 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewPagePathEffect() {
71873   void * jresult ;
71874   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71875
71876   {
71877     try {
71878       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71879     } catch (std::out_of_range& e) {
71880       {
71881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71882       };
71883     } catch (std::exception& e) {
71884       {
71885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71886       };
71887     } catch (...) {
71888       {
71889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71890       };
71891     }
71892   }
71893   jresult = (void *)result;
71894   return jresult;
71895 }
71896
71897
71898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71899   void * jresult ;
71900   Dali::BaseHandle arg1 ;
71901   Dali::BaseHandle *argp1 ;
71902   Dali::Toolkit::ScrollViewPagePathEffect result;
71903
71904   argp1 = (Dali::BaseHandle *)jarg1;
71905   if (!argp1) {
71906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71907     return 0;
71908   }
71909   arg1 = *argp1;
71910   {
71911     try {
71912       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71913     } catch (std::out_of_range& e) {
71914       {
71915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71916       };
71917     } catch (std::exception& e) {
71918       {
71919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71920       };
71921     } catch (...) {
71922       {
71923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71924       };
71925     }
71926   }
71927   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71928   return jresult;
71929 }
71930
71931
71932 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71933   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71934   Dali::Actor arg2 ;
71935   unsigned int arg3 ;
71936   Dali::Actor *argp2 ;
71937
71938   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71939   argp2 = (Dali::Actor *)jarg2;
71940   if (!argp2) {
71941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71942     return ;
71943   }
71944   arg2 = *argp2;
71945   arg3 = (unsigned int)jarg3;
71946   {
71947     try {
71948       (arg1)->ApplyToPage(arg2,arg3);
71949     } catch (std::out_of_range& e) {
71950       {
71951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71952       };
71953     } catch (std::exception& e) {
71954       {
71955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71956       };
71957     } catch (...) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71960       };
71961     }
71962   }
71963 }
71964
71965
71966 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewPagePathEffect(void * jarg1) {
71967   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71968
71969   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71970   {
71971     try {
71972       delete arg1;
71973     } catch (std::out_of_range& e) {
71974       {
71975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71976       };
71977     } catch (std::exception& e) {
71978       {
71979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71980       };
71981     } catch (...) {
71982       {
71983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71984       };
71985     }
71986   }
71987 }
71988
71989
71990 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ClampState2D_x_set(void * jarg1, int jarg2) {
71991   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71992   Dali::Toolkit::ClampState arg2 ;
71993
71994   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71995   arg2 = (Dali::Toolkit::ClampState)jarg2;
71996   if (arg1) (arg1)->x = arg2;
71997 }
71998
71999
72000 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ClampState2D_x_get(void * jarg1) {
72001   int jresult ;
72002   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72003   Dali::Toolkit::ClampState result;
72004
72005   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72006   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72007   jresult = (int)result;
72008   return jresult;
72009 }
72010
72011
72012 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ClampState2D_y_set(void * jarg1, int jarg2) {
72013   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72014   Dali::Toolkit::ClampState arg2 ;
72015
72016   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72017   arg2 = (Dali::Toolkit::ClampState)jarg2;
72018   if (arg1) (arg1)->y = arg2;
72019 }
72020
72021
72022 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ClampState2D_y_get(void * jarg1) {
72023   int jresult ;
72024   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72025   Dali::Toolkit::ClampState result;
72026
72027   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72028   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72029   jresult = (int)result;
72030   return jresult;
72031 }
72032
72033
72034 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ClampState2D() {
72035   void * jresult ;
72036   Dali::Toolkit::ClampState2D *result = 0 ;
72037
72038   {
72039     try {
72040       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72041     } catch (std::out_of_range& e) {
72042       {
72043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72044       };
72045     } catch (std::exception& e) {
72046       {
72047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (...) {
72050       {
72051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72052       };
72053     }
72054   }
72055   jresult = (void *)result;
72056   return jresult;
72057 }
72058
72059
72060 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ClampState2D(void * jarg1) {
72061   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72062
72063   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72064   {
72065     try {
72066       delete arg1;
72067     } catch (std::out_of_range& e) {
72068       {
72069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72070       };
72071     } catch (std::exception& e) {
72072       {
72073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72074       };
72075     } catch (...) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72078       };
72079     }
72080   }
72081 }
72082
72083
72084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72085   void * jresult ;
72086   float arg1 ;
72087   float arg2 ;
72088   bool arg3 ;
72089   Dali::Toolkit::RulerDomain *result = 0 ;
72090
72091   arg1 = (float)jarg1;
72092   arg2 = (float)jarg2;
72093   arg3 = jarg3 ? true : false;
72094   {
72095     try {
72096       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72097     } catch (std::out_of_range& e) {
72098       {
72099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72100       };
72101     } catch (std::exception& e) {
72102       {
72103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (...) {
72106       {
72107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72108       };
72109     }
72110   }
72111   jresult = (void *)result;
72112   return jresult;
72113 }
72114
72115
72116 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72117   void * jresult ;
72118   float arg1 ;
72119   float arg2 ;
72120   Dali::Toolkit::RulerDomain *result = 0 ;
72121
72122   arg1 = (float)jarg1;
72123   arg2 = (float)jarg2;
72124   {
72125     try {
72126       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72127     } catch (std::out_of_range& e) {
72128       {
72129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72130       };
72131     } catch (std::exception& e) {
72132       {
72133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72134       };
72135     } catch (...) {
72136       {
72137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72138       };
72139     }
72140   }
72141   jresult = (void *)result;
72142   return jresult;
72143 }
72144
72145
72146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_min_set(void * jarg1, float jarg2) {
72147   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72148   float arg2 ;
72149
72150   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72151   arg2 = (float)jarg2;
72152   if (arg1) (arg1)->min = arg2;
72153 }
72154
72155
72156 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_min_get(void * jarg1) {
72157   float jresult ;
72158   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72159   float result;
72160
72161   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72162   result = (float) ((arg1)->min);
72163   jresult = result;
72164   return jresult;
72165 }
72166
72167
72168 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_max_set(void * jarg1, float jarg2) {
72169   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72170   float arg2 ;
72171
72172   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72173   arg2 = (float)jarg2;
72174   if (arg1) (arg1)->max = arg2;
72175 }
72176
72177
72178 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_max_get(void * jarg1) {
72179   float jresult ;
72180   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72181   float result;
72182
72183   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72184   result = (float) ((arg1)->max);
72185   jresult = result;
72186   return jresult;
72187 }
72188
72189
72190 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72191   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72192   bool arg2 ;
72193
72194   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72195   arg2 = jarg2 ? true : false;
72196   if (arg1) (arg1)->enabled = arg2;
72197 }
72198
72199
72200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerDomain_enabled_get(void * jarg1) {
72201   unsigned int jresult ;
72202   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72203   bool result;
72204
72205   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72206   result = (bool) ((arg1)->enabled);
72207   jresult = result;
72208   return jresult;
72209 }
72210
72211
72212 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72213   float jresult ;
72214   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72215   float arg2 ;
72216   float arg3 ;
72217   float arg4 ;
72218   float result;
72219
72220   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72221   arg2 = (float)jarg2;
72222   arg3 = (float)jarg3;
72223   arg4 = (float)jarg4;
72224   {
72225     try {
72226       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72227     } catch (std::out_of_range& e) {
72228       {
72229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72230       };
72231     } catch (std::exception& e) {
72232       {
72233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72234       };
72235     } catch (...) {
72236       {
72237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72238       };
72239     }
72240   }
72241   jresult = result;
72242   return jresult;
72243 }
72244
72245
72246 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72247   float jresult ;
72248   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72249   float arg2 ;
72250   float arg3 ;
72251   float result;
72252
72253   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72254   arg2 = (float)jarg2;
72255   arg3 = (float)jarg3;
72256   {
72257     try {
72258       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72259     } catch (std::out_of_range& e) {
72260       {
72261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72262       };
72263     } catch (std::exception& e) {
72264       {
72265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (...) {
72268       {
72269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72270       };
72271     }
72272   }
72273   jresult = result;
72274   return jresult;
72275 }
72276
72277
72278 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72279   float jresult ;
72280   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72281   float arg2 ;
72282   float result;
72283
72284   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72285   arg2 = (float)jarg2;
72286   {
72287     try {
72288       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72289     } catch (std::out_of_range& e) {
72290       {
72291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72292       };
72293     } catch (std::exception& e) {
72294       {
72295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72300       };
72301     }
72302   }
72303   jresult = result;
72304   return jresult;
72305 }
72306
72307
72308 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72309   float jresult ;
72310   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72311   float arg2 ;
72312   float arg3 ;
72313   float arg4 ;
72314   Dali::Toolkit::ClampState *arg5 = 0 ;
72315   float result;
72316
72317   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72318   arg2 = (float)jarg2;
72319   arg3 = (float)jarg3;
72320   arg4 = (float)jarg4;
72321   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72322   if (!arg5) {
72323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72324     return 0;
72325   }
72326   {
72327     try {
72328       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72329     } catch (std::out_of_range& e) {
72330       {
72331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72332       };
72333     } catch (std::exception& e) {
72334       {
72335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72336       };
72337     } catch (...) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72340       };
72341     }
72342   }
72343   jresult = result;
72344   return jresult;
72345 }
72346
72347
72348 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_GetSize(void * jarg1) {
72349   float jresult ;
72350   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72351   float result;
72352
72353   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72354   {
72355     try {
72356       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72357     } catch (std::out_of_range& e) {
72358       {
72359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72360       };
72361     } catch (std::exception& e) {
72362       {
72363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72364       };
72365     } catch (...) {
72366       {
72367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72368       };
72369     }
72370   }
72371   jresult = result;
72372   return jresult;
72373 }
72374
72375
72376 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RulerDomain(void * jarg1) {
72377   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72378
72379   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72380   {
72381     try {
72382       delete arg1;
72383     } catch (std::out_of_range& e) {
72384       {
72385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72386       };
72387     } catch (std::exception& e) {
72388       {
72389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72390       };
72391     } catch (...) {
72392       {
72393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72394       };
72395     }
72396   }
72397 }
72398
72399
72400 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72401   float jresult ;
72402   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72403   float arg2 ;
72404   float arg3 ;
72405   float result;
72406
72407   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72408   arg2 = (float)jarg2;
72409   arg3 = (float)jarg3;
72410   {
72411     try {
72412       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72413     } catch (std::out_of_range& e) {
72414       {
72415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72416       };
72417     } catch (std::exception& e) {
72418       {
72419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (...) {
72422       {
72423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72424       };
72425     }
72426   }
72427   jresult = result;
72428   return jresult;
72429 }
72430
72431
72432 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72433   float jresult ;
72434   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72435   float arg2 ;
72436   float result;
72437
72438   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72439   arg2 = (float)jarg2;
72440   {
72441     try {
72442       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72443     } catch (std::out_of_range& e) {
72444       {
72445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72446       };
72447     } catch (std::exception& e) {
72448       {
72449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72450       };
72451     } catch (...) {
72452       {
72453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72454       };
72455     }
72456   }
72457   jresult = result;
72458   return jresult;
72459 }
72460
72461
72462 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72463   float jresult ;
72464   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72465   unsigned int arg2 ;
72466   unsigned int *arg3 = 0 ;
72467   bool arg4 ;
72468   float result;
72469
72470   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72471   arg2 = (unsigned int)jarg2;
72472   arg3 = (unsigned int *)jarg3;
72473   arg4 = jarg4 ? true : false;
72474   {
72475     try {
72476       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (...) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72488       };
72489     }
72490   }
72491   jresult = result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72497   unsigned int jresult ;
72498   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72499   float arg2 ;
72500   bool arg3 ;
72501   unsigned int result;
72502
72503   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72504   arg2 = (float)jarg2;
72505   arg3 = jarg3 ? true : false;
72506   {
72507     try {
72508       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72509     } catch (std::out_of_range& e) {
72510       {
72511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72512       };
72513     } catch (std::exception& e) {
72514       {
72515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72516       };
72517     } catch (...) {
72518       {
72519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72520       };
72521     }
72522   }
72523   jresult = result;
72524   return jresult;
72525 }
72526
72527
72528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_GetTotalPages(void * jarg1) {
72529   unsigned int jresult ;
72530   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72531   unsigned int result;
72532
72533   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72534   {
72535     try {
72536       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72537     } catch (std::out_of_range& e) {
72538       {
72539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72540       };
72541     } catch (std::exception& e) {
72542       {
72543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (...) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72548       };
72549     }
72550   }
72551   jresult = result;
72552   return jresult;
72553 }
72554
72555
72556 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Ruler_GetType(void * jarg1) {
72557   int jresult ;
72558   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72559   Dali::Toolkit::Ruler::RulerType result;
72560
72561   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72562   {
72563     try {
72564       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72565     } catch (std::out_of_range& e) {
72566       {
72567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72568       };
72569     } catch (std::exception& e) {
72570       {
72571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72572       };
72573     } catch (...) {
72574       {
72575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72576       };
72577     }
72578   }
72579   jresult = (int)result;
72580   return jresult;
72581 }
72582
72583
72584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_IsEnabled(void * jarg1) {
72585   unsigned int jresult ;
72586   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72587   bool result;
72588
72589   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72590   {
72591     try {
72592       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72593     } catch (std::out_of_range& e) {
72594       {
72595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72596       };
72597     } catch (std::exception& e) {
72598       {
72599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72600       };
72601     } catch (...) {
72602       {
72603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72604       };
72605     }
72606   }
72607   jresult = result;
72608   return jresult;
72609 }
72610
72611
72612 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_Enable(void * jarg1) {
72613   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72614
72615   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72616   {
72617     try {
72618       (arg1)->Enable();
72619     } catch (std::out_of_range& e) {
72620       {
72621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72622       };
72623     } catch (std::exception& e) {
72624       {
72625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72626       };
72627     } catch (...) {
72628       {
72629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72630       };
72631     }
72632   }
72633 }
72634
72635
72636 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_Disable(void * jarg1) {
72637   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72638
72639   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72640   {
72641     try {
72642       (arg1)->Disable();
72643     } catch (std::out_of_range& e) {
72644       {
72645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72646       };
72647     } catch (std::exception& e) {
72648       {
72649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72650       };
72651     } catch (...) {
72652       {
72653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72654       };
72655     }
72656   }
72657 }
72658
72659
72660 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_SetDomain(void * jarg1, void * jarg2) {
72661   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72662   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72663   Dali::Toolkit::RulerDomain *argp2 ;
72664
72665   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72666   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72667   if (!argp2) {
72668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72669     return ;
72670   }
72671   arg2 = *argp2;
72672   {
72673     try {
72674       (arg1)->SetDomain(arg2);
72675     } catch (std::out_of_range& e) {
72676       {
72677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72678       };
72679     } catch (std::exception& e) {
72680       {
72681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72682       };
72683     } catch (...) {
72684       {
72685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72686       };
72687     }
72688   }
72689 }
72690
72691
72692 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Ruler_GetDomain(void * jarg1) {
72693   void * jresult ;
72694   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72695   Dali::Toolkit::RulerDomain *result = 0 ;
72696
72697   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72698   {
72699     try {
72700       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72701     } catch (std::out_of_range& e) {
72702       {
72703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72704       };
72705     } catch (std::exception& e) {
72706       {
72707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72708       };
72709     } catch (...) {
72710       {
72711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72712       };
72713     }
72714   }
72715   jresult = (void *)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_DisableDomain(void * jarg1) {
72721   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72722
72723   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72724   {
72725     try {
72726       (arg1)->DisableDomain();
72727     } catch (std::out_of_range& e) {
72728       {
72729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72730       };
72731     } catch (std::exception& e) {
72732       {
72733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72734       };
72735     } catch (...) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72738       };
72739     }
72740   }
72741 }
72742
72743
72744 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72745   float jresult ;
72746   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72747   float arg2 ;
72748   float arg3 ;
72749   float arg4 ;
72750   float result;
72751
72752   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72753   arg2 = (float)jarg2;
72754   arg3 = (float)jarg3;
72755   arg4 = (float)jarg4;
72756   {
72757     try {
72758       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72759     } catch (std::out_of_range& e) {
72760       {
72761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72762       };
72763     } catch (std::exception& e) {
72764       {
72765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (...) {
72768       {
72769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72770       };
72771     }
72772   }
72773   jresult = result;
72774   return jresult;
72775 }
72776
72777
72778 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72779   float jresult ;
72780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72781   float arg2 ;
72782   float arg3 ;
72783   float result;
72784
72785   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72786   arg2 = (float)jarg2;
72787   arg3 = (float)jarg3;
72788   {
72789     try {
72790       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72791     } catch (std::out_of_range& e) {
72792       {
72793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72794       };
72795     } catch (std::exception& e) {
72796       {
72797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72798       };
72799     } catch (...) {
72800       {
72801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72802       };
72803     }
72804   }
72805   jresult = result;
72806   return jresult;
72807 }
72808
72809
72810 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72811   float jresult ;
72812   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72813   float arg2 ;
72814   float result;
72815
72816   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72817   arg2 = (float)jarg2;
72818   {
72819     try {
72820       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72828       };
72829     } catch (...) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72832       };
72833     }
72834   }
72835   jresult = result;
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72841   float jresult ;
72842   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72843   float arg2 ;
72844   float arg3 ;
72845   float arg4 ;
72846   Dali::Toolkit::ClampState *arg5 = 0 ;
72847   float result;
72848
72849   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72850   arg2 = (float)jarg2;
72851   arg3 = (float)jarg3;
72852   arg4 = (float)jarg4;
72853   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72854   if (!arg5) {
72855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72856     return 0;
72857   }
72858   {
72859     try {
72860       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72861     } catch (std::out_of_range& e) {
72862       {
72863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72864       };
72865     } catch (std::exception& e) {
72866       {
72867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72868       };
72869     } catch (...) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72872       };
72873     }
72874   }
72875   jresult = result;
72876   return jresult;
72877 }
72878
72879
72880 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72881   float jresult ;
72882   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72883   float arg2 ;
72884   float arg3 ;
72885   float arg4 ;
72886   float arg5 ;
72887   float result;
72888
72889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72890   arg2 = (float)jarg2;
72891   arg3 = (float)jarg3;
72892   arg4 = (float)jarg4;
72893   arg5 = (float)jarg5;
72894   {
72895     try {
72896       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72897     } catch (std::out_of_range& e) {
72898       {
72899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72900       };
72901     } catch (std::exception& e) {
72902       {
72903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72908       };
72909     }
72910   }
72911   jresult = result;
72912   return jresult;
72913 }
72914
72915
72916 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72917   float jresult ;
72918   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72919   float arg2 ;
72920   float arg3 ;
72921   float arg4 ;
72922   float result;
72923
72924   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72925   arg2 = (float)jarg2;
72926   arg3 = (float)jarg3;
72927   arg4 = (float)jarg4;
72928   {
72929     try {
72930       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72931     } catch (std::out_of_range& e) {
72932       {
72933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72934       };
72935     } catch (std::exception& e) {
72936       {
72937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72938       };
72939     } catch (...) {
72940       {
72941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72942       };
72943     }
72944   }
72945   jresult = result;
72946   return jresult;
72947 }
72948
72949
72950 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72951   float jresult ;
72952   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72953   float arg2 ;
72954   float arg3 ;
72955   float result;
72956
72957   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72958   arg2 = (float)jarg2;
72959   arg3 = (float)jarg3;
72960   {
72961     try {
72962       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72963     } catch (std::out_of_range& e) {
72964       {
72965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72966       };
72967     } catch (std::exception& e) {
72968       {
72969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (...) {
72972       {
72973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72974       };
72975     }
72976   }
72977   jresult = result;
72978   return jresult;
72979 }
72980
72981
72982 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72983   float jresult ;
72984   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72985   float arg2 ;
72986   float result;
72987
72988   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72989   arg2 = (float)jarg2;
72990   {
72991     try {
72992       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72993     } catch (std::out_of_range& e) {
72994       {
72995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72996       };
72997     } catch (std::exception& e) {
72998       {
72999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73000       };
73001     } catch (...) {
73002       {
73003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73004       };
73005     }
73006   }
73007   jresult = result;
73008   return jresult;
73009 }
73010
73011
73012 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73013   float jresult ;
73014   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73015   float arg2 ;
73016   float arg3 ;
73017   float arg4 ;
73018   float arg5 ;
73019   Dali::Toolkit::ClampState *arg6 = 0 ;
73020   float result;
73021
73022   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73023   arg2 = (float)jarg2;
73024   arg3 = (float)jarg3;
73025   arg4 = (float)jarg4;
73026   arg5 = (float)jarg5;
73027   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73028   if (!arg6) {
73029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73030     return 0;
73031   }
73032   {
73033     try {
73034       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73035     } catch (std::out_of_range& e) {
73036       {
73037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73038       };
73039     } catch (std::exception& e) {
73040       {
73041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73042       };
73043     } catch (...) {
73044       {
73045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73046       };
73047     }
73048   }
73049   jresult = result;
73050   return jresult;
73051 }
73052
73053
73054 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DefaultRuler() {
73055   void * jresult ;
73056   Dali::Toolkit::DefaultRuler *result = 0 ;
73057
73058   {
73059     try {
73060       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73061     } catch (std::out_of_range& e) {
73062       {
73063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73064       };
73065     } catch (std::exception& e) {
73066       {
73067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73068       };
73069     } catch (...) {
73070       {
73071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73072       };
73073     }
73074   }
73075   jresult = (void *)result;
73076   return jresult;
73077 }
73078
73079
73080 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73081   float jresult ;
73082   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73083   float arg2 ;
73084   float arg3 ;
73085   float result;
73086
73087   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73088   arg2 = (float)jarg2;
73089   arg3 = (float)jarg3;
73090   {
73091     try {
73092       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73093     } catch (std::out_of_range& e) {
73094       {
73095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73096       };
73097     } catch (std::exception& e) {
73098       {
73099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73100       };
73101     } catch (...) {
73102       {
73103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73104       };
73105     }
73106   }
73107   jresult = result;
73108   return jresult;
73109 }
73110
73111
73112 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73113   float jresult ;
73114   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73115   unsigned int arg2 ;
73116   unsigned int *arg3 = 0 ;
73117   bool arg4 ;
73118   float result;
73119
73120   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73121   arg2 = (unsigned int)jarg2;
73122   arg3 = (unsigned int *)jarg3;
73123   arg4 = jarg4 ? true : false;
73124   {
73125     try {
73126       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73127     } catch (std::out_of_range& e) {
73128       {
73129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (std::exception& e) {
73132       {
73133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (...) {
73136       {
73137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73138       };
73139     }
73140   }
73141   jresult = result;
73142   return jresult;
73143 }
73144
73145
73146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73147   unsigned int jresult ;
73148   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73149   float arg2 ;
73150   bool arg3 ;
73151   unsigned int result;
73152
73153   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73154   arg2 = (float)jarg2;
73155   arg3 = jarg3 ? true : false;
73156   {
73157     try {
73158       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (...) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73170       };
73171     }
73172   }
73173   jresult = result;
73174   return jresult;
73175 }
73176
73177
73178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DefaultRuler_GetTotalPages(void * jarg1) {
73179   unsigned int jresult ;
73180   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73181   unsigned int result;
73182
73183   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73184   {
73185     try {
73186       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73187     } catch (std::out_of_range& e) {
73188       {
73189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73190       };
73191     } catch (std::exception& e) {
73192       {
73193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73194       };
73195     } catch (...) {
73196       {
73197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73198       };
73199     }
73200   }
73201   jresult = result;
73202   return jresult;
73203 }
73204
73205
73206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DefaultRuler(void * jarg1) {
73207   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73208
73209   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73210   {
73211     try {
73212       delete arg1;
73213     } catch (std::out_of_range& e) {
73214       {
73215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73216       };
73217     } catch (std::exception& e) {
73218       {
73219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73220       };
73221     } catch (...) {
73222       {
73223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73224       };
73225     }
73226   }
73227 }
73228
73229
73230 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FixedRuler__SWIG_0(float jarg1) {
73231   void * jresult ;
73232   float arg1 ;
73233   Dali::Toolkit::FixedRuler *result = 0 ;
73234
73235   arg1 = (float)jarg1;
73236   {
73237     try {
73238       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73239     } catch (std::out_of_range& e) {
73240       {
73241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73242       };
73243     } catch (std::exception& e) {
73244       {
73245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73246       };
73247     } catch (...) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73250       };
73251     }
73252   }
73253   jresult = (void *)result;
73254   return jresult;
73255 }
73256
73257
73258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FixedRuler__SWIG_1() {
73259   void * jresult ;
73260   Dali::Toolkit::FixedRuler *result = 0 ;
73261
73262   {
73263     try {
73264       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73265     } catch (std::out_of_range& e) {
73266       {
73267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73268       };
73269     } catch (std::exception& e) {
73270       {
73271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73272       };
73273     } catch (...) {
73274       {
73275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73276       };
73277     }
73278   }
73279   jresult = (void *)result;
73280   return jresult;
73281 }
73282
73283
73284 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73285   float jresult ;
73286   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73287   float arg2 ;
73288   float arg3 ;
73289   float result;
73290
73291   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73292   arg2 = (float)jarg2;
73293   arg3 = (float)jarg3;
73294   {
73295     try {
73296       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73297     } catch (std::out_of_range& e) {
73298       {
73299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73300       };
73301     } catch (std::exception& e) {
73302       {
73303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73304       };
73305     } catch (...) {
73306       {
73307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73308       };
73309     }
73310   }
73311   jresult = result;
73312   return jresult;
73313 }
73314
73315
73316 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73317   float jresult ;
73318   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73319   unsigned int arg2 ;
73320   unsigned int *arg3 = 0 ;
73321   bool arg4 ;
73322   float result;
73323
73324   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73325   arg2 = (unsigned int)jarg2;
73326   arg3 = (unsigned int *)jarg3;
73327   arg4 = jarg4 ? true : false;
73328   {
73329     try {
73330       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73331     } catch (std::out_of_range& e) {
73332       {
73333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73334       };
73335     } catch (std::exception& e) {
73336       {
73337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73338       };
73339     } catch (...) {
73340       {
73341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73342       };
73343     }
73344   }
73345   jresult = result;
73346   return jresult;
73347 }
73348
73349
73350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73351   unsigned int jresult ;
73352   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73353   float arg2 ;
73354   bool arg3 ;
73355   unsigned int result;
73356
73357   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73358   arg2 = (float)jarg2;
73359   arg3 = jarg3 ? true : false;
73360   {
73361     try {
73362       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73363     } catch (std::out_of_range& e) {
73364       {
73365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73366       };
73367     } catch (std::exception& e) {
73368       {
73369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73370       };
73371     } catch (...) {
73372       {
73373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73374       };
73375     }
73376   }
73377   jresult = result;
73378   return jresult;
73379 }
73380
73381
73382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FixedRuler_GetTotalPages(void * jarg1) {
73383   unsigned int jresult ;
73384   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73385   unsigned int result;
73386
73387   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73388   {
73389     try {
73390       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73391     } catch (std::out_of_range& e) {
73392       {
73393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73394       };
73395     } catch (std::exception& e) {
73396       {
73397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73398       };
73399     } catch (...) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73402       };
73403     }
73404   }
73405   jresult = result;
73406   return jresult;
73407 }
73408
73409
73410 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FixedRuler(void * jarg1) {
73411   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73412
73413   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73414   {
73415     try {
73416       delete arg1;
73417     } catch (std::out_of_range& e) {
73418       {
73419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73420       };
73421     } catch (std::exception& e) {
73422       {
73423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73424       };
73425     } catch (...) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73428       };
73429     }
73430   }
73431 }
73432
73433
73434 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73435   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73436   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73437
73438   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73439   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73440   if (arg1) (arg1)->scale = *arg2;
73441 }
73442
73443
73444 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_scale_get(void * jarg1) {
73445   void * jresult ;
73446   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73447   Dali::Toolkit::ClampState2D *result = 0 ;
73448
73449   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73450   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73451   jresult = (void *)result;
73452   return jresult;
73453 }
73454
73455
73456 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73457   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73458   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73459
73460   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73461   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73462   if (arg1) (arg1)->position = *arg2;
73463 }
73464
73465
73466 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_position_get(void * jarg1) {
73467   void * jresult ;
73468   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73469   Dali::Toolkit::ClampState2D *result = 0 ;
73470
73471   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73472   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73473   jresult = (void *)result;
73474   return jresult;
73475 }
73476
73477
73478 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73479   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73480   Dali::Toolkit::ClampState arg2 ;
73481
73482   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73483   arg2 = (Dali::Toolkit::ClampState)jarg2;
73484   if (arg1) (arg1)->rotation = arg2;
73485 }
73486
73487
73488 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73489   int jresult ;
73490   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73491   Dali::Toolkit::ClampState result;
73492
73493   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73494   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73495   jresult = (int)result;
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_ClampEvent() {
73501   void * jresult ;
73502   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73503
73504   {
73505     try {
73506       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73507     } catch (std::out_of_range& e) {
73508       {
73509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73510       };
73511     } catch (std::exception& e) {
73512       {
73513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73514       };
73515     } catch (...) {
73516       {
73517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73518       };
73519     }
73520   }
73521   jresult = (void *)result;
73522   return jresult;
73523 }
73524
73525
73526 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_ClampEvent(void * jarg1) {
73527   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73528
73529   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73530   {
73531     try {
73532       delete arg1;
73533     } catch (std::out_of_range& e) {
73534       {
73535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73536       };
73537     } catch (std::exception& e) {
73538       {
73539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73540       };
73541     } catch (...) {
73542       {
73543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73544       };
73545     }
73546   }
73547 }
73548
73549
73550 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73551   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73552   Dali::Toolkit::SnapType arg2 ;
73553
73554   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73555   arg2 = (Dali::Toolkit::SnapType)jarg2;
73556   if (arg1) (arg1)->type = arg2;
73557 }
73558
73559
73560 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_type_get(void * jarg1) {
73561   int jresult ;
73562   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73563   Dali::Toolkit::SnapType result;
73564
73565   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73566   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73567   jresult = (int)result;
73568   return jresult;
73569 }
73570
73571
73572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73573   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73574   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73575
73576   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73577   arg2 = (Dali::Vector2 *)jarg2;
73578   if (arg1) (arg1)->position = *arg2;
73579 }
73580
73581
73582 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_position_get(void * jarg1) {
73583   void * jresult ;
73584   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73585   Dali::Vector2 *result = 0 ;
73586
73587   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73588   result = (Dali::Vector2 *)& ((arg1)->position);
73589   jresult = (void *)result;
73590   return jresult;
73591 }
73592
73593
73594 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73595   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73596   float arg2 ;
73597
73598   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73599   arg2 = (float)jarg2;
73600   if (arg1) (arg1)->duration = arg2;
73601 }
73602
73603
73604 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_duration_get(void * jarg1) {
73605   float jresult ;
73606   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73607   float result;
73608
73609   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73610   result = (float) ((arg1)->duration);
73611   jresult = result;
73612   return jresult;
73613 }
73614
73615
73616 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_SnapEvent() {
73617   void * jresult ;
73618   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73619
73620   {
73621     try {
73622       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73623     } catch (std::out_of_range& e) {
73624       {
73625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73626       };
73627     } catch (std::exception& e) {
73628       {
73629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73630       };
73631     } catch (...) {
73632       {
73633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73634       };
73635     }
73636   }
73637   jresult = (void *)result;
73638   return jresult;
73639 }
73640
73641
73642 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_SnapEvent(void * jarg1) {
73643   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73644
73645   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73646   {
73647     try {
73648       delete arg1;
73649     } catch (std::out_of_range& e) {
73650       {
73651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73652       };
73653     } catch (std::exception& e) {
73654       {
73655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73656       };
73657     } catch (...) {
73658       {
73659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73660       };
73661     }
73662   }
73663 }
73664
73665
73666 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WRAP_ENABLED_get() {
73667   int jresult ;
73668   int result;
73669
73670   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73671   jresult = (int)result;
73672   return jresult;
73673 }
73674
73675
73676 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_PANNING_ENABLED_get() {
73677   int jresult ;
73678   int result;
73679
73680   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73681   jresult = (int)result;
73682   return jresult;
73683 }
73684
73685
73686 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73687   int jresult ;
73688   int result;
73689
73690   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73691   jresult = (int)result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73697   int jresult ;
73698   int result;
73699
73700   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73701   jresult = (int)result;
73702   return jresult;
73703 }
73704
73705
73706 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_POSITION_get() {
73707   int jresult ;
73708   int result;
73709
73710   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73711   jresult = (int)result;
73712   return jresult;
73713 }
73714
73715
73716 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73717   int jresult ;
73718   int result;
73719
73720   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73721   jresult = (int)result;
73722   return jresult;
73723 }
73724
73725
73726 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73727   int jresult ;
73728   int result;
73729
73730   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73731   jresult = (int)result;
73732   return jresult;
73733 }
73734
73735
73736 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73737   int jresult ;
73738   int result;
73739
73740   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73741   jresult = (int)result;
73742   return jresult;
73743 }
73744
73745
73746 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73747   int jresult ;
73748   int result;
73749
73750   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73751   jresult = (int)result;
73752   return jresult;
73753 }
73754
73755
73756 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73757   int jresult ;
73758   int result;
73759
73760   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73761   jresult = (int)result;
73762   return jresult;
73763 }
73764
73765
73766 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73767   int jresult ;
73768   int result;
73769
73770   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73771   jresult = (int)result;
73772   return jresult;
73773 }
73774
73775
73776 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_OVERSHOOT_X_get() {
73777   int jresult ;
73778   int result;
73779
73780   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73781   jresult = (int)result;
73782   return jresult;
73783 }
73784
73785
73786 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_OVERSHOOT_Y_get() {
73787   int jresult ;
73788   int result;
73789
73790   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73791   jresult = (int)result;
73792   return jresult;
73793 }
73794
73795
73796 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_get() {
73797   int jresult ;
73798   int result;
73799
73800   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73801   jresult = (int)result;
73802   return jresult;
73803 }
73804
73805
73806 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_X_get() {
73807   int jresult ;
73808   int result;
73809
73810   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73811   jresult = (int)result;
73812   return jresult;
73813 }
73814
73815
73816 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_Y_get() {
73817   int jresult ;
73818   int result;
73819
73820   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73821   jresult = (int)result;
73822   return jresult;
73823 }
73824
73825
73826 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WRAP_get() {
73827   int jresult ;
73828   int result;
73829
73830   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73831   jresult = (int)result;
73832   return jresult;
73833 }
73834
73835
73836 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_PANNING_get() {
73837   int jresult ;
73838   int result;
73839
73840   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73841   jresult = (int)result;
73842   return jresult;
73843 }
73844
73845
73846 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLLING_get() {
73847   int jresult ;
73848   int result;
73849
73850   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73851   jresult = (int)result;
73852   return jresult;
73853 }
73854
73855
73856 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73857   int jresult ;
73858   int result;
73859
73860   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73861   jresult = (int)result;
73862   return jresult;
73863 }
73864
73865
73866 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73867   int jresult ;
73868   int result;
73869
73870   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73871   jresult = (int)result;
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73877   int jresult ;
73878   int result;
73879
73880   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73881   jresult = (int)result;
73882   return jresult;
73883 }
73884
73885
73886 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73887   int jresult ;
73888   int result;
73889
73890   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73891   jresult = (int)result;
73892   return jresult;
73893 }
73894
73895
73896 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73897   int jresult ;
73898   int result;
73899
73900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73901   jresult = (int)result;
73902   return jresult;
73903 }
73904
73905
73906 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_START_PAGE_POSITION_get() {
73907   int jresult ;
73908   int result;
73909
73910   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73911   jresult = (int)result;
73912   return jresult;
73913 }
73914
73915
73916 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_Property() {
73917   void * jresult ;
73918   Dali::Toolkit::ScrollView::Property *result = 0 ;
73919
73920   {
73921     try {
73922       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73923     } catch (std::out_of_range& e) {
73924       {
73925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73926       };
73927     } catch (std::exception& e) {
73928       {
73929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73930       };
73931     } catch (...) {
73932       {
73933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73934       };
73935     }
73936   }
73937   jresult = (void *)result;
73938   return jresult;
73939 }
73940
73941
73942 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_Property(void * jarg1) {
73943   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73944
73945   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73946   {
73947     try {
73948       delete arg1;
73949     } catch (std::out_of_range& e) {
73950       {
73951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73952       };
73953     } catch (std::exception& e) {
73954       {
73955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73956       };
73957     } catch (...) {
73958       {
73959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73960       };
73961     }
73962   }
73963 }
73964
73965
73966 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView__SWIG_0() {
73967   void * jresult ;
73968   Dali::Toolkit::ScrollView *result = 0 ;
73969
73970   {
73971     try {
73972       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73980       };
73981     } catch (...) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73984       };
73985     }
73986   }
73987   jresult = (void *)result;
73988   return jresult;
73989 }
73990
73991
73992 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView__SWIG_1(void * jarg1) {
73993   void * jresult ;
73994   Dali::Toolkit::ScrollView *arg1 = 0 ;
73995   Dali::Toolkit::ScrollView *result = 0 ;
73996
73997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73998   if (!arg1) {
73999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74000     return 0;
74001   }
74002   {
74003     try {
74004       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74005     } catch (std::out_of_range& e) {
74006       {
74007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74008       };
74009     } catch (std::exception& e) {
74010       {
74011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74012       };
74013     } catch (...) {
74014       {
74015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74016       };
74017     }
74018   }
74019   jresult = (void *)result;
74020   return jresult;
74021 }
74022
74023
74024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_Assign(void * jarg1, void * jarg2) {
74025   void * jresult ;
74026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74027   Dali::Toolkit::ScrollView *arg2 = 0 ;
74028   Dali::Toolkit::ScrollView *result = 0 ;
74029
74030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74031   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74032   if (!arg2) {
74033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74034     return 0;
74035   }
74036   {
74037     try {
74038       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74039     } catch (std::out_of_range& e) {
74040       {
74041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74042       };
74043     } catch (std::exception& e) {
74044       {
74045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74046       };
74047     } catch (...) {
74048       {
74049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74050       };
74051     }
74052   }
74053   jresult = (void *)result;
74054   return jresult;
74055 }
74056
74057
74058 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView(void * jarg1) {
74059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74060
74061   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74062   {
74063     try {
74064       delete arg1;
74065     } catch (std::out_of_range& e) {
74066       {
74067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74068       };
74069     } catch (std::exception& e) {
74070       {
74071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74072       };
74073     } catch (...) {
74074       {
74075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74076       };
74077     }
74078   }
74079 }
74080
74081
74082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_New() {
74083   void * jresult ;
74084   Dali::Toolkit::ScrollView result;
74085
74086   {
74087     try {
74088       result = Dali::Toolkit::ScrollView::New();
74089     } catch (std::out_of_range& e) {
74090       {
74091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74092       };
74093     } catch (std::exception& e) {
74094       {
74095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74096       };
74097     } catch (...) {
74098       {
74099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74100       };
74101     }
74102   }
74103   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74104   return jresult;
74105 }
74106
74107
74108 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_DownCast(void * jarg1) {
74109   void * jresult ;
74110   Dali::BaseHandle arg1 ;
74111   Dali::BaseHandle *argp1 ;
74112   Dali::Toolkit::ScrollView result;
74113
74114   argp1 = (Dali::BaseHandle *)jarg1;
74115   if (!argp1) {
74116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74117     return 0;
74118   }
74119   arg1 = *argp1;
74120   {
74121     try {
74122       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74123     } catch (std::out_of_range& e) {
74124       {
74125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74126       };
74127     } catch (std::exception& e) {
74128       {
74129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74130       };
74131     } catch (...) {
74132       {
74133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74134       };
74135     }
74136   }
74137   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74138   return jresult;
74139 }
74140
74141
74142 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74143   void * jresult ;
74144   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74145   Dali::AlphaFunction result;
74146
74147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74148   {
74149     try {
74150       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74151     } catch (std::out_of_range& e) {
74152       {
74153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (std::exception& e) {
74156       {
74157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74158       };
74159     } catch (...) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74162       };
74163     }
74164   }
74165   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74166   return jresult;
74167 }
74168
74169
74170 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74172   Dali::AlphaFunction arg2 ;
74173   Dali::AlphaFunction *argp2 ;
74174
74175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74176   argp2 = (Dali::AlphaFunction *)jarg2;
74177   if (!argp2) {
74178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74179     return ;
74180   }
74181   arg2 = *argp2;
74182   {
74183     try {
74184       (arg1)->SetScrollSnapAlphaFunction(arg2);
74185     } catch (std::out_of_range& e) {
74186       {
74187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74188       };
74189     } catch (std::exception& e) {
74190       {
74191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74192       };
74193     } catch (...) {
74194       {
74195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74196       };
74197     }
74198   }
74199 }
74200
74201
74202 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74203   void * jresult ;
74204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74205   Dali::AlphaFunction result;
74206
74207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74208   {
74209     try {
74210       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74211     } catch (std::out_of_range& e) {
74212       {
74213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74214       };
74215     } catch (std::exception& e) {
74216       {
74217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74218       };
74219     } catch (...) {
74220       {
74221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74222       };
74223     }
74224   }
74225   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74232   Dali::AlphaFunction arg2 ;
74233   Dali::AlphaFunction *argp2 ;
74234
74235   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74236   argp2 = (Dali::AlphaFunction *)jarg2;
74237   if (!argp2) {
74238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74239     return ;
74240   }
74241   arg2 = *argp2;
74242   {
74243     try {
74244       (arg1)->SetScrollFlickAlphaFunction(arg2);
74245     } catch (std::out_of_range& e) {
74246       {
74247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74248       };
74249     } catch (std::exception& e) {
74250       {
74251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74252       };
74253     } catch (...) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74256       };
74257     }
74258   }
74259 }
74260
74261
74262 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollSnapDuration(void * jarg1) {
74263   float jresult ;
74264   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74265   float result;
74266
74267   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74268   {
74269     try {
74270       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
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 = result;
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74291   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74292   float arg2 ;
74293
74294   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74295   arg2 = (float)jarg2;
74296   {
74297     try {
74298       (arg1)->SetScrollSnapDuration(arg2);
74299     } catch (std::out_of_range& e) {
74300       {
74301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74302       };
74303     } catch (std::exception& e) {
74304       {
74305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74306       };
74307     } catch (...) {
74308       {
74309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74310       };
74311     }
74312   }
74313 }
74314
74315
74316 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollFlickDuration(void * jarg1) {
74317   float jresult ;
74318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74319   float result;
74320
74321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74322   {
74323     try {
74324       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74325     } catch (std::out_of_range& e) {
74326       {
74327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74328       };
74329     } catch (std::exception& e) {
74330       {
74331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74332       };
74333     } catch (...) {
74334       {
74335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74336       };
74337     }
74338   }
74339   jresult = result;
74340   return jresult;
74341 }
74342
74343
74344 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74346   float arg2 ;
74347
74348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74349   arg2 = (float)jarg2;
74350   {
74351     try {
74352       (arg1)->SetScrollFlickDuration(arg2);
74353     } catch (std::out_of_range& e) {
74354       {
74355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74356       };
74357     } catch (std::exception& e) {
74358       {
74359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74360       };
74361     } catch (...) {
74362       {
74363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74364       };
74365     }
74366   }
74367 }
74368
74369
74370 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74372   Dali::Toolkit::RulerPtr arg2 ;
74373   Dali::Toolkit::RulerPtr *argp2 ;
74374
74375   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74376   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74377   if (!argp2) {
74378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74379     return ;
74380   }
74381   arg2 = *argp2;
74382   {
74383     try {
74384       (arg1)->SetRulerX(arg2);
74385     } catch (std::out_of_range& e) {
74386       {
74387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (std::exception& e) {
74390       {
74391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74396       };
74397     }
74398   }
74399 }
74400
74401
74402 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74404   Dali::Toolkit::RulerPtr arg2 ;
74405   Dali::Toolkit::RulerPtr *argp2 ;
74406
74407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74408   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74409   if (!argp2) {
74410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74411     return ;
74412   }
74413   arg2 = *argp2;
74414   {
74415     try {
74416       (arg1)->SetRulerY(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_NUI_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74436   bool arg2 ;
74437
74438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74439   arg2 = jarg2 ? true : false;
74440   {
74441     try {
74442       (arg1)->SetScrollSensitive(arg2);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74450       };
74451     } catch (...) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74454       };
74455     }
74456   }
74457 }
74458
74459
74460 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74462   float arg2 ;
74463   float arg3 ;
74464
74465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74466   arg2 = (float)jarg2;
74467   arg3 = (float)jarg3;
74468   {
74469     try {
74470       (arg1)->SetMaxOvershoot(arg2,arg3);
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74478       };
74479     } catch (...) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74482       };
74483     }
74484   }
74485 }
74486
74487
74488 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74490   Dali::AlphaFunction arg2 ;
74491   Dali::AlphaFunction *argp2 ;
74492
74493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74494   argp2 = (Dali::AlphaFunction *)jarg2;
74495   if (!argp2) {
74496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74497     return ;
74498   }
74499   arg2 = *argp2;
74500   {
74501     try {
74502       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74510       };
74511     } catch (...) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74514       };
74515     }
74516   }
74517 }
74518
74519
74520 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74522   float arg2 ;
74523
74524   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74525   arg2 = (float)jarg2;
74526   {
74527     try {
74528       (arg1)->SetSnapOvershootDuration(arg2);
74529     } catch (std::out_of_range& e) {
74530       {
74531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (std::exception& e) {
74534       {
74535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74540       };
74541     }
74542   }
74543 }
74544
74545
74546 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74548   bool arg2 ;
74549
74550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74551   arg2 = jarg2 ? true : false;
74552   {
74553     try {
74554       (arg1)->SetActorAutoSnap(arg2);
74555     } catch (std::out_of_range& e) {
74556       {
74557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74558       };
74559     } catch (std::exception& e) {
74560       {
74561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74562       };
74563     } catch (...) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74566       };
74567     }
74568   }
74569 }
74570
74571
74572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74574   bool arg2 ;
74575
74576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74577   arg2 = jarg2 ? true : false;
74578   {
74579     try {
74580       (arg1)->SetWrapMode(arg2);
74581     } catch (std::out_of_range& e) {
74582       {
74583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74584       };
74585     } catch (std::exception& e) {
74586       {
74587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74588       };
74589     } catch (...) {
74590       {
74591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74592       };
74593     }
74594   }
74595 }
74596
74597
74598 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74599   int jresult ;
74600   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74601   int result;
74602
74603   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74604   {
74605     try {
74606       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74607     } catch (std::out_of_range& e) {
74608       {
74609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74610       };
74611     } catch (std::exception& e) {
74612       {
74613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74614       };
74615     } catch (...) {
74616       {
74617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74618       };
74619     }
74620   }
74621   jresult = result;
74622   return jresult;
74623 }
74624
74625
74626 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74628   int arg2 ;
74629
74630   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74631   arg2 = (int)jarg2;
74632   {
74633     try {
74634       (arg1)->SetScrollUpdateDistance(arg2);
74635     } catch (std::out_of_range& e) {
74636       {
74637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (std::exception& e) {
74640       {
74641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74642       };
74643     } catch (...) {
74644       {
74645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74646       };
74647     }
74648   }
74649 }
74650
74651
74652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_GetAxisAutoLock(void * jarg1) {
74653   unsigned int jresult ;
74654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74655   bool result;
74656
74657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74658   {
74659     try {
74660       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74661     } catch (std::out_of_range& e) {
74662       {
74663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (std::exception& e) {
74666       {
74667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (...) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74672       };
74673     }
74674   }
74675   jresult = result;
74676   return jresult;
74677 }
74678
74679
74680 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74681   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74682   bool arg2 ;
74683
74684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74685   arg2 = jarg2 ? true : false;
74686   {
74687     try {
74688       (arg1)->SetAxisAutoLock(arg2);
74689     } catch (std::out_of_range& e) {
74690       {
74691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74692       };
74693     } catch (std::exception& e) {
74694       {
74695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74700       };
74701     }
74702   }
74703 }
74704
74705
74706 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74707   float jresult ;
74708   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74709   float result;
74710
74711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74712   {
74713     try {
74714       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74715     } catch (std::out_of_range& e) {
74716       {
74717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74718       };
74719     } catch (std::exception& e) {
74720       {
74721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74722       };
74723     } catch (...) {
74724       {
74725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74726       };
74727     }
74728   }
74729   jresult = result;
74730   return jresult;
74731 }
74732
74733
74734 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74736   float arg2 ;
74737
74738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74739   arg2 = (float)jarg2;
74740   {
74741     try {
74742       (arg1)->SetAxisAutoLockGradient(arg2);
74743     } catch (std::out_of_range& e) {
74744       {
74745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74746       };
74747     } catch (std::exception& e) {
74748       {
74749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74750       };
74751     } catch (...) {
74752       {
74753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74754       };
74755     }
74756   }
74757 }
74758
74759
74760 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetFrictionCoefficient(void * jarg1) {
74761   float jresult ;
74762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74763   float result;
74764
74765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74766   {
74767     try {
74768       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74769     } catch (std::out_of_range& e) {
74770       {
74771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74772       };
74773     } catch (std::exception& e) {
74774       {
74775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74776       };
74777     } catch (...) {
74778       {
74779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74780       };
74781     }
74782   }
74783   jresult = result;
74784   return jresult;
74785 }
74786
74787
74788 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74789   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74790   float arg2 ;
74791
74792   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74793   arg2 = (float)jarg2;
74794   {
74795     try {
74796       (arg1)->SetFrictionCoefficient(arg2);
74797     } catch (std::out_of_range& e) {
74798       {
74799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74800       };
74801     } catch (std::exception& e) {
74802       {
74803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74804       };
74805     } catch (...) {
74806       {
74807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74808       };
74809     }
74810   }
74811 }
74812
74813
74814 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74815   float jresult ;
74816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74817   float result;
74818
74819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74820   {
74821     try {
74822       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74823     } catch (std::out_of_range& e) {
74824       {
74825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74826       };
74827     } catch (std::exception& e) {
74828       {
74829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74830       };
74831     } catch (...) {
74832       {
74833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74834       };
74835     }
74836   }
74837   jresult = result;
74838   return jresult;
74839 }
74840
74841
74842 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74844   float arg2 ;
74845
74846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74847   arg2 = (float)jarg2;
74848   {
74849     try {
74850       (arg1)->SetFlickSpeedCoefficient(arg2);
74851     } catch (std::out_of_range& e) {
74852       {
74853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74854       };
74855     } catch (std::exception& e) {
74856       {
74857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74858       };
74859     } catch (...) {
74860       {
74861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74862       };
74863     }
74864   }
74865 }
74866
74867
74868 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74869   void * jresult ;
74870   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74871   Dali::Vector2 result;
74872
74873   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74874   {
74875     try {
74876       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74877     } catch (std::out_of_range& e) {
74878       {
74879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74880       };
74881     } catch (std::exception& e) {
74882       {
74883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74884       };
74885     } catch (...) {
74886       {
74887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74888       };
74889     }
74890   }
74891   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74892   return jresult;
74893 }
74894
74895
74896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74898   Dali::Vector2 *arg2 = 0 ;
74899
74900   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74901   arg2 = (Dali::Vector2 *)jarg2;
74902   if (!arg2) {
74903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74904     return ;
74905   }
74906   {
74907     try {
74908       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74909     } catch (std::out_of_range& e) {
74910       {
74911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74912       };
74913     } catch (std::exception& e) {
74914       {
74915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74916       };
74917     } catch (...) {
74918       {
74919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74920       };
74921     }
74922   }
74923 }
74924
74925
74926 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74927   float jresult ;
74928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74929   float result;
74930
74931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74932   {
74933     try {
74934       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74935     } catch (std::out_of_range& e) {
74936       {
74937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74938       };
74939     } catch (std::exception& e) {
74940       {
74941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74942       };
74943     } catch (...) {
74944       {
74945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74946       };
74947     }
74948   }
74949   jresult = result;
74950   return jresult;
74951 }
74952
74953
74954 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74956   float arg2 ;
74957
74958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74959   arg2 = (float)jarg2;
74960   {
74961     try {
74962       (arg1)->SetMinimumSpeedForFlick(arg2);
74963     } catch (std::out_of_range& e) {
74964       {
74965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74966       };
74967     } catch (std::exception& e) {
74968       {
74969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74970       };
74971     } catch (...) {
74972       {
74973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74974       };
74975     }
74976   }
74977 }
74978
74979
74980 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74981   float jresult ;
74982   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74983   float result;
74984
74985   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74986   {
74987     try {
74988       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74989     } catch (std::out_of_range& e) {
74990       {
74991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (std::exception& e) {
74994       {
74995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (...) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75000       };
75001     }
75002   }
75003   jresult = result;
75004   return jresult;
75005 }
75006
75007
75008 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75010   float arg2 ;
75011
75012   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75013   arg2 = (float)jarg2;
75014   {
75015     try {
75016       (arg1)->SetMaxFlickSpeed(arg2);
75017     } catch (std::out_of_range& e) {
75018       {
75019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75020       };
75021     } catch (std::exception& e) {
75022       {
75023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75024       };
75025     } catch (...) {
75026       {
75027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75028       };
75029     }
75030   }
75031 }
75032
75033
75034 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75035   void * jresult ;
75036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75037   Dali::Vector2 result;
75038
75039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75040   {
75041     try {
75042       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75043     } catch (std::out_of_range& e) {
75044       {
75045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75046       };
75047     } catch (std::exception& e) {
75048       {
75049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75050       };
75051     } catch (...) {
75052       {
75053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75054       };
75055     }
75056   }
75057   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75058   return jresult;
75059 }
75060
75061
75062 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75063   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75064   Dali::Vector2 arg2 ;
75065   Dali::Vector2 *argp2 ;
75066
75067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75068   argp2 = (Dali::Vector2 *)jarg2;
75069   if (!argp2) {
75070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75071     return ;
75072   }
75073   arg2 = *argp2;
75074   {
75075     try {
75076       (arg1)->SetWheelScrollDistanceStep(arg2);
75077     } catch (std::out_of_range& e) {
75078       {
75079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (std::exception& e) {
75082       {
75083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75084       };
75085     } catch (...) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75088       };
75089     }
75090   }
75091 }
75092
75093
75094 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75095   void * jresult ;
75096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75097   Dali::Vector2 result;
75098
75099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75100   {
75101     try {
75102       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75103     } catch (std::out_of_range& e) {
75104       {
75105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75106       };
75107     } catch (std::exception& e) {
75108       {
75109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75110       };
75111     } catch (...) {
75112       {
75113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75114       };
75115     }
75116   }
75117   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75118   return jresult;
75119 }
75120
75121
75122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_GetCurrentPage(void * jarg1) {
75123   unsigned int jresult ;
75124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75125   unsigned int result;
75126
75127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75128   {
75129     try {
75130       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75131     } catch (std::out_of_range& e) {
75132       {
75133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75134       };
75135     } catch (std::exception& e) {
75136       {
75137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75138       };
75139     } catch (...) {
75140       {
75141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75142       };
75143     }
75144   }
75145   jresult = result;
75146   return jresult;
75147 }
75148
75149
75150 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75152   Dali::Vector2 *arg2 = 0 ;
75153
75154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75155   arg2 = (Dali::Vector2 *)jarg2;
75156   if (!arg2) {
75157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75158     return ;
75159   }
75160   {
75161     try {
75162       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75163     } catch (std::out_of_range& e) {
75164       {
75165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75166       };
75167     } catch (std::exception& e) {
75168       {
75169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75174       };
75175     }
75176   }
75177 }
75178
75179
75180 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75181   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75182   Dali::Vector2 *arg2 = 0 ;
75183   float arg3 ;
75184
75185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75186   arg2 = (Dali::Vector2 *)jarg2;
75187   if (!arg2) {
75188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75189     return ;
75190   }
75191   arg3 = (float)jarg3;
75192   {
75193     try {
75194       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
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 void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75214   Dali::Vector2 *arg2 = 0 ;
75215   float arg3 ;
75216   Dali::AlphaFunction arg4 ;
75217   Dali::AlphaFunction *argp4 ;
75218
75219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75220   arg2 = (Dali::Vector2 *)jarg2;
75221   if (!arg2) {
75222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75223     return ;
75224   }
75225   arg3 = (float)jarg3;
75226   argp4 = (Dali::AlphaFunction *)jarg4;
75227   if (!argp4) {
75228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75229     return ;
75230   }
75231   arg4 = *argp4;
75232   {
75233     try {
75234       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75235     } catch (std::out_of_range& e) {
75236       {
75237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75238       };
75239     } catch (std::exception& e) {
75240       {
75241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75242       };
75243     } catch (...) {
75244       {
75245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75246       };
75247     }
75248   }
75249 }
75250
75251
75252 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75253   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75254   Dali::Vector2 *arg2 = 0 ;
75255   float arg3 ;
75256   Dali::Toolkit::DirectionBias arg4 ;
75257   Dali::Toolkit::DirectionBias arg5 ;
75258
75259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75260   arg2 = (Dali::Vector2 *)jarg2;
75261   if (!arg2) {
75262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75263     return ;
75264   }
75265   arg3 = (float)jarg3;
75266   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75267   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75268   {
75269     try {
75270       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75271     } catch (std::out_of_range& e) {
75272       {
75273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75274       };
75275     } catch (std::exception& e) {
75276       {
75277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (...) {
75280       {
75281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75282       };
75283     }
75284   }
75285 }
75286
75287
75288 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75290   Dali::Vector2 *arg2 = 0 ;
75291   float arg3 ;
75292   Dali::AlphaFunction arg4 ;
75293   Dali::Toolkit::DirectionBias arg5 ;
75294   Dali::Toolkit::DirectionBias arg6 ;
75295   Dali::AlphaFunction *argp4 ;
75296
75297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75298   arg2 = (Dali::Vector2 *)jarg2;
75299   if (!arg2) {
75300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75301     return ;
75302   }
75303   arg3 = (float)jarg3;
75304   argp4 = (Dali::AlphaFunction *)jarg4;
75305   if (!argp4) {
75306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75307     return ;
75308   }
75309   arg4 = *argp4;
75310   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75311   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75312   {
75313     try {
75314       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (...) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75326       };
75327     }
75328   }
75329 }
75330
75331
75332 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75334   unsigned int arg2 ;
75335
75336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75337   arg2 = (unsigned int)jarg2;
75338   {
75339     try {
75340       (arg1)->ScrollTo(arg2);
75341     } catch (std::out_of_range& e) {
75342       {
75343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75344       };
75345     } catch (std::exception& e) {
75346       {
75347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75348       };
75349     } catch (...) {
75350       {
75351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75352       };
75353     }
75354   }
75355 }
75356
75357
75358 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75359   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75360   unsigned int arg2 ;
75361   float arg3 ;
75362
75363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75364   arg2 = (unsigned int)jarg2;
75365   arg3 = (float)jarg3;
75366   {
75367     try {
75368       (arg1)->ScrollTo(arg2,arg3);
75369     } catch (std::out_of_range& e) {
75370       {
75371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75372       };
75373     } catch (std::exception& e) {
75374       {
75375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75376       };
75377     } catch (...) {
75378       {
75379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75380       };
75381     }
75382   }
75383 }
75384
75385
75386 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75388   unsigned int arg2 ;
75389   float arg3 ;
75390   Dali::Toolkit::DirectionBias arg4 ;
75391
75392   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75393   arg2 = (unsigned int)jarg2;
75394   arg3 = (float)jarg3;
75395   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75396   {
75397     try {
75398       (arg1)->ScrollTo(arg2,arg3,arg4);
75399     } catch (std::out_of_range& e) {
75400       {
75401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75402       };
75403     } catch (std::exception& e) {
75404       {
75405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75406       };
75407     } catch (...) {
75408       {
75409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75410       };
75411     }
75412   }
75413 }
75414
75415
75416 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75418   Dali::Actor *arg2 = 0 ;
75419
75420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75421   arg2 = (Dali::Actor *)jarg2;
75422   if (!arg2) {
75423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75424     return ;
75425   }
75426   {
75427     try {
75428       (arg1)->ScrollTo(*arg2);
75429     } catch (std::out_of_range& e) {
75430       {
75431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75432       };
75433     } catch (std::exception& e) {
75434       {
75435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75436       };
75437     } catch (...) {
75438       {
75439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75440       };
75441     }
75442   }
75443 }
75444
75445
75446 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75448   Dali::Actor *arg2 = 0 ;
75449   float arg3 ;
75450
75451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75452   arg2 = (Dali::Actor *)jarg2;
75453   if (!arg2) {
75454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75455     return ;
75456   }
75457   arg3 = (float)jarg3;
75458   {
75459     try {
75460       (arg1)->ScrollTo(*arg2,arg3);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75468       };
75469     } catch (...) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75472       };
75473     }
75474   }
75475 }
75476
75477
75478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_ScrollToSnapPoint(void * jarg1) {
75479   unsigned int jresult ;
75480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75481   bool result;
75482
75483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75484   {
75485     try {
75486       result = (bool)(arg1)->ScrollToSnapPoint();
75487     } catch (std::out_of_range& e) {
75488       {
75489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75490       };
75491     } catch (std::exception& e) {
75492       {
75493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75498       };
75499     }
75500   }
75501   jresult = result;
75502   return jresult;
75503 }
75504
75505
75506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75508   Dali::Constraint arg2 ;
75509   Dali::Constraint *argp2 ;
75510
75511   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75512   argp2 = (Dali::Constraint *)jarg2;
75513   if (!argp2) {
75514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75515     return ;
75516   }
75517   arg2 = *argp2;
75518   {
75519     try {
75520       (arg1)->ApplyConstraintToChildren(arg2);
75521     } catch (std::out_of_range& e) {
75522       {
75523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75524       };
75525     } catch (std::exception& e) {
75526       {
75527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75528       };
75529     } catch (...) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75532       };
75533     }
75534   }
75535 }
75536
75537
75538 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75540
75541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75542   {
75543     try {
75544       (arg1)->RemoveConstraintsFromChildren();
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75556       };
75557     }
75558   }
75559 }
75560
75561
75562 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75564   Dali::Toolkit::ScrollViewEffect arg2 ;
75565   Dali::Toolkit::ScrollViewEffect *argp2 ;
75566
75567   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75568   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75569   if (!argp2) {
75570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75571     return ;
75572   }
75573   arg2 = *argp2;
75574   {
75575     try {
75576       (arg1)->ApplyEffect(arg2);
75577     } catch (std::out_of_range& e) {
75578       {
75579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75580       };
75581     } catch (std::exception& e) {
75582       {
75583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75584       };
75585     } catch (...) {
75586       {
75587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75588       };
75589     }
75590   }
75591 }
75592
75593
75594 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75595   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75596   Dali::Toolkit::ScrollViewEffect arg2 ;
75597   Dali::Toolkit::ScrollViewEffect *argp2 ;
75598
75599   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75600   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75601   if (!argp2) {
75602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75603     return ;
75604   }
75605   arg2 = *argp2;
75606   {
75607     try {
75608       (arg1)->RemoveEffect(arg2);
75609     } catch (std::out_of_range& e) {
75610       {
75611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75612       };
75613     } catch (std::exception& e) {
75614       {
75615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75616       };
75617     } catch (...) {
75618       {
75619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75620       };
75621     }
75622   }
75623 }
75624
75625
75626 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveAllEffects(void * jarg1) {
75627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75628
75629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75630   {
75631     try {
75632       (arg1)->RemoveAllEffects();
75633     } catch (std::out_of_range& e) {
75634       {
75635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75636       };
75637     } catch (std::exception& e) {
75638       {
75639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75640       };
75641     } catch (...) {
75642       {
75643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75644       };
75645     }
75646   }
75647 }
75648
75649
75650 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_BindActor(void * jarg1, void * jarg2) {
75651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75652   Dali::Actor arg2 ;
75653   Dali::Actor *argp2 ;
75654
75655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75656   argp2 = (Dali::Actor *)jarg2;
75657   if (!argp2) {
75658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75659     return ;
75660   }
75661   arg2 = *argp2;
75662   {
75663     try {
75664       (arg1)->BindActor(arg2);
75665     } catch (std::out_of_range& e) {
75666       {
75667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75668       };
75669     } catch (std::exception& e) {
75670       {
75671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75676       };
75677     }
75678   }
75679 }
75680
75681
75682 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75683   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75684   Dali::Actor arg2 ;
75685   Dali::Actor *argp2 ;
75686
75687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75688   argp2 = (Dali::Actor *)jarg2;
75689   if (!argp2) {
75690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75691     return ;
75692   }
75693   arg2 = *argp2;
75694   {
75695     try {
75696       (arg1)->UnbindActor(arg2);
75697     } catch (std::out_of_range& e) {
75698       {
75699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (std::exception& e) {
75702       {
75703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75708       };
75709     }
75710   }
75711 }
75712
75713
75714 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75716   Dali::Radian arg2 ;
75717   Dali::Radian arg3 ;
75718   Dali::Radian *argp2 ;
75719   Dali::Radian *argp3 ;
75720
75721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75722   argp2 = (Dali::Radian *)jarg2;
75723   if (!argp2) {
75724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75725     return ;
75726   }
75727   arg2 = *argp2;
75728   argp3 = (Dali::Radian *)jarg3;
75729   if (!argp3) {
75730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75731     return ;
75732   }
75733   arg3 = *argp3;
75734   {
75735     try {
75736       (arg1)->SetScrollingDirection(arg2,arg3);
75737     } catch (std::out_of_range& e) {
75738       {
75739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75740       };
75741     } catch (std::exception& e) {
75742       {
75743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75744       };
75745     } catch (...) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75748       };
75749     }
75750   }
75751 }
75752
75753
75754 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75755   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75756   Dali::Radian arg2 ;
75757   Dali::Radian *argp2 ;
75758
75759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75760   argp2 = (Dali::Radian *)jarg2;
75761   if (!argp2) {
75762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75763     return ;
75764   }
75765   arg2 = *argp2;
75766   {
75767     try {
75768       (arg1)->SetScrollingDirection(arg2);
75769     } catch (std::out_of_range& e) {
75770       {
75771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75772       };
75773     } catch (std::exception& e) {
75774       {
75775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75776       };
75777     } catch (...) {
75778       {
75779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75780       };
75781     }
75782   }
75783 }
75784
75785
75786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75788   Dali::Radian arg2 ;
75789   Dali::Radian *argp2 ;
75790
75791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75792   argp2 = (Dali::Radian *)jarg2;
75793   if (!argp2) {
75794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75795     return ;
75796   }
75797   arg2 = *argp2;
75798   {
75799     try {
75800       (arg1)->RemoveScrollingDirection(arg2);
75801     } catch (std::out_of_range& e) {
75802       {
75803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75804       };
75805     } catch (std::exception& e) {
75806       {
75807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (...) {
75810       {
75811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75812       };
75813     }
75814   }
75815 }
75816
75817
75818 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_SnapStartedSignal(void * jarg1) {
75819   void * jresult ;
75820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75821   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75822
75823   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75824   {
75825     try {
75826       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75827     } catch (std::out_of_range& e) {
75828       {
75829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75830       };
75831     } catch (std::exception& e) {
75832       {
75833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75834       };
75835     } catch (...) {
75836       {
75837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75838       };
75839     }
75840   }
75841   jresult = (void *)result;
75842   return jresult;
75843 }
75844
75845
75846 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_ROWS_get() {
75847   int jresult ;
75848   int result;
75849
75850   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75851   jresult = (int)result;
75852   return jresult;
75853 }
75854
75855
75856 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_COLUMNS_get() {
75857   int jresult ;
75858   int result;
75859
75860   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75861   jresult = (int)result;
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_CELL_PADDING_get() {
75867   int jresult ;
75868   int result;
75869
75870   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75871   jresult = (int)result;
75872   return jresult;
75873 }
75874
75875
75876 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_LAYOUT_ROWS_get() {
75877   int jresult ;
75878   int result;
75879
75880   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75881   jresult = (int)result;
75882   return jresult;
75883 }
75884
75885
75886 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_LAYOUT_COLUMNS_get() {
75887   int jresult ;
75888   int result;
75889
75890   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75891   jresult = (int)result;
75892   return jresult;
75893 }
75894
75895
75896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_Property() {
75897   void * jresult ;
75898   Dali::Toolkit::TableView::Property *result = 0 ;
75899
75900   {
75901     try {
75902       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75903     } catch (std::out_of_range& e) {
75904       {
75905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75906       };
75907     } catch (std::exception& e) {
75908       {
75909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75910       };
75911     } catch (...) {
75912       {
75913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75914       };
75915     }
75916   }
75917   jresult = (void *)result;
75918   return jresult;
75919 }
75920
75921
75922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_Property(void * jarg1) {
75923   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75924
75925   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75926   {
75927     try {
75928       delete arg1;
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 int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_INDEX_get() {
75947   int jresult ;
75948   int result;
75949
75950   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75951   jresult = (int)result;
75952   return jresult;
75953 }
75954
75955
75956 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_ROW_SPAN_get() {
75957   int jresult ;
75958   int result;
75959
75960   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75961   jresult = (int)result;
75962   return jresult;
75963 }
75964
75965
75966 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_COLUMN_SPAN_get() {
75967   int jresult ;
75968   int result;
75969
75970   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75971   jresult = (int)result;
75972   return jresult;
75973 }
75974
75975
75976 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75977   int jresult ;
75978   int result;
75979
75980   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75981   jresult = (int)result;
75982   return jresult;
75983 }
75984
75985
75986 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75987   int jresult ;
75988   int result;
75989
75990   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75991   jresult = (int)result;
75992   return jresult;
75993 }
75994
75995
75996 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_ChildProperty() {
75997   void * jresult ;
75998   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75999
76000   {
76001     try {
76002       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76003     } catch (std::out_of_range& e) {
76004       {
76005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76006       };
76007     } catch (std::exception& e) {
76008       {
76009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76010       };
76011     } catch (...) {
76012       {
76013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76014       };
76015     }
76016   }
76017   jresult = (void *)result;
76018   return jresult;
76019 }
76020
76021
76022 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_ChildProperty(void * jarg1) {
76023   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76024
76025   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76026   {
76027     try {
76028       delete arg1;
76029     } catch (std::out_of_range& e) {
76030       {
76031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76032       };
76033     } catch (std::exception& e) {
76034       {
76035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76036       };
76037     } catch (...) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76040       };
76041     }
76042   }
76043 }
76044
76045
76046 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76047   void * jresult ;
76048   unsigned int arg1 ;
76049   unsigned int arg2 ;
76050   unsigned int arg3 ;
76051   unsigned int arg4 ;
76052   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76053
76054   arg1 = (unsigned int)jarg1;
76055   arg2 = (unsigned int)jarg2;
76056   arg3 = (unsigned int)jarg3;
76057   arg4 = (unsigned int)jarg4;
76058   {
76059     try {
76060       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76061     } catch (std::out_of_range& e) {
76062       {
76063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76064       };
76065     } catch (std::exception& e) {
76066       {
76067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76068       };
76069     } catch (...) {
76070       {
76071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76072       };
76073     }
76074   }
76075   jresult = (void *)result;
76076   return jresult;
76077 }
76078
76079
76080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76081   void * jresult ;
76082   unsigned int arg1 ;
76083   unsigned int arg2 ;
76084   unsigned int arg3 ;
76085   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76086
76087   arg1 = (unsigned int)jarg1;
76088   arg2 = (unsigned int)jarg2;
76089   arg3 = (unsigned int)jarg3;
76090   {
76091     try {
76092       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76093     } catch (std::out_of_range& e) {
76094       {
76095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76096       };
76097     } catch (std::exception& e) {
76098       {
76099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76100       };
76101     } catch (...) {
76102       {
76103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76104       };
76105     }
76106   }
76107   jresult = (void *)result;
76108   return jresult;
76109 }
76110
76111
76112 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76113   void * jresult ;
76114   unsigned int arg1 ;
76115   unsigned int arg2 ;
76116   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76117
76118   arg1 = (unsigned int)jarg1;
76119   arg2 = (unsigned int)jarg2;
76120   {
76121     try {
76122       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76123     } catch (std::out_of_range& e) {
76124       {
76125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76126       };
76127     } catch (std::exception& e) {
76128       {
76129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76130       };
76131     } catch (...) {
76132       {
76133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76134       };
76135     }
76136   }
76137   jresult = (void *)result;
76138   return jresult;
76139 }
76140
76141
76142 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76143   void * jresult ;
76144   unsigned int arg1 ;
76145   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76146
76147   arg1 = (unsigned int)jarg1;
76148   {
76149     try {
76150       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76151     } catch (std::out_of_range& e) {
76152       {
76153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76154       };
76155     } catch (std::exception& e) {
76156       {
76157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76162       };
76163     }
76164   }
76165   jresult = (void *)result;
76166   return jresult;
76167 }
76168
76169
76170 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_4() {
76171   void * jresult ;
76172   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76173
76174   {
76175     try {
76176       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76177     } catch (std::out_of_range& e) {
76178       {
76179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76180       };
76181     } catch (std::exception& e) {
76182       {
76183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76184       };
76185     } catch (...) {
76186       {
76187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76188       };
76189     }
76190   }
76191   jresult = (void *)result;
76192   return jresult;
76193 }
76194
76195
76196 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76197   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76198   unsigned int arg2 ;
76199
76200   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76201   arg2 = (unsigned int)jarg2;
76202   if (arg1) (arg1)->rowIndex = arg2;
76203 }
76204
76205
76206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowIndex_get(void * jarg1) {
76207   unsigned int jresult ;
76208   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76209   unsigned int result;
76210
76211   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76212   result = (unsigned int) ((arg1)->rowIndex);
76213   jresult = result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76219   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76220   unsigned int arg2 ;
76221
76222   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76223   arg2 = (unsigned int)jarg2;
76224   if (arg1) (arg1)->columnIndex = arg2;
76225 }
76226
76227
76228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnIndex_get(void * jarg1) {
76229   unsigned int jresult ;
76230   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76231   unsigned int result;
76232
76233   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76234   result = (unsigned int) ((arg1)->columnIndex);
76235   jresult = result;
76236   return jresult;
76237 }
76238
76239
76240 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76241   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76242   unsigned int arg2 ;
76243
76244   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76245   arg2 = (unsigned int)jarg2;
76246   if (arg1) (arg1)->rowSpan = arg2;
76247 }
76248
76249
76250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowSpan_get(void * jarg1) {
76251   unsigned int jresult ;
76252   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76253   unsigned int result;
76254
76255   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76256   result = (unsigned int) ((arg1)->rowSpan);
76257   jresult = result;
76258   return jresult;
76259 }
76260
76261
76262 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76263   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76264   unsigned int arg2 ;
76265
76266   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76267   arg2 = (unsigned int)jarg2;
76268   if (arg1) (arg1)->columnSpan = arg2;
76269 }
76270
76271
76272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnSpan_get(void * jarg1) {
76273   unsigned int jresult ;
76274   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76275   unsigned int result;
76276
76277   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76278   result = (unsigned int) ((arg1)->columnSpan);
76279   jresult = result;
76280   return jresult;
76281 }
76282
76283
76284 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_CellPosition(void * jarg1) {
76285   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76286
76287   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76288   {
76289     try {
76290       delete arg1;
76291     } catch (std::out_of_range& e) {
76292       {
76293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (std::exception& e) {
76296       {
76297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76298       };
76299     } catch (...) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76302       };
76303     }
76304   }
76305 }
76306
76307
76308 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView__SWIG_0() {
76309   void * jresult ;
76310   Dali::Toolkit::TableView *result = 0 ;
76311
76312   {
76313     try {
76314       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76315     } catch (std::out_of_range& e) {
76316       {
76317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (std::exception& e) {
76320       {
76321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (...) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76326       };
76327     }
76328   }
76329   jresult = (void *)result;
76330   return jresult;
76331 }
76332
76333
76334 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView__SWIG_1(void * jarg1) {
76335   void * jresult ;
76336   Dali::Toolkit::TableView *arg1 = 0 ;
76337   Dali::Toolkit::TableView *result = 0 ;
76338
76339   arg1 = (Dali::Toolkit::TableView *)jarg1;
76340   if (!arg1) {
76341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76342     return 0;
76343   }
76344   {
76345     try {
76346       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76347     } catch (std::out_of_range& e) {
76348       {
76349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76350       };
76351     } catch (std::exception& e) {
76352       {
76353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76354       };
76355     } catch (...) {
76356       {
76357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76358       };
76359     }
76360   }
76361   jresult = (void *)result;
76362   return jresult;
76363 }
76364
76365
76366 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_Assign(void * jarg1, void * jarg2) {
76367   void * jresult ;
76368   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76369   Dali::Toolkit::TableView *arg2 = 0 ;
76370   Dali::Toolkit::TableView *result = 0 ;
76371
76372   arg1 = (Dali::Toolkit::TableView *)jarg1;
76373   arg2 = (Dali::Toolkit::TableView *)jarg2;
76374   if (!arg2) {
76375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76376     return 0;
76377   }
76378   {
76379     try {
76380       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76381     } catch (std::out_of_range& e) {
76382       {
76383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (std::exception& e) {
76386       {
76387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76388       };
76389     } catch (...) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76392       };
76393     }
76394   }
76395   jresult = (void *)result;
76396   return jresult;
76397 }
76398
76399
76400 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView(void * jarg1) {
76401   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76402
76403   arg1 = (Dali::Toolkit::TableView *)jarg1;
76404   {
76405     try {
76406       delete arg1;
76407     } catch (std::out_of_range& e) {
76408       {
76409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76410       };
76411     } catch (std::exception& e) {
76412       {
76413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76414       };
76415     } catch (...) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76418       };
76419     }
76420   }
76421 }
76422
76423
76424 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76425   void * jresult ;
76426   unsigned int arg1 ;
76427   unsigned int arg2 ;
76428   Dali::Toolkit::TableView result;
76429
76430   arg1 = (unsigned int)jarg1;
76431   arg2 = (unsigned int)jarg2;
76432   {
76433     try {
76434       result = Dali::Toolkit::TableView::New(arg1,arg2);
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (...) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76446       };
76447     }
76448   }
76449   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76450   return jresult;
76451 }
76452
76453
76454 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_DownCast(void * jarg1) {
76455   void * jresult ;
76456   Dali::BaseHandle arg1 ;
76457   Dali::BaseHandle *argp1 ;
76458   Dali::Toolkit::TableView result;
76459
76460   argp1 = (Dali::BaseHandle *)jarg1;
76461   if (!argp1) {
76462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76463     return 0;
76464   }
76465   arg1 = *argp1;
76466   {
76467     try {
76468       result = Dali::Toolkit::TableView::DownCast(arg1);
76469     } catch (std::out_of_range& e) {
76470       {
76471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76472       };
76473     } catch (std::exception& e) {
76474       {
76475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76476       };
76477     } catch (...) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76480       };
76481     }
76482   }
76483   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76484   return jresult;
76485 }
76486
76487
76488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76489   unsigned int jresult ;
76490   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76491   Dali::Actor arg2 ;
76492   Dali::Toolkit::TableView::CellPosition arg3 ;
76493   Dali::Actor *argp2 ;
76494   Dali::Toolkit::TableView::CellPosition *argp3 ;
76495   bool result;
76496
76497   arg1 = (Dali::Toolkit::TableView *)jarg1;
76498   argp2 = (Dali::Actor *)jarg2;
76499   if (!argp2) {
76500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76501     return 0;
76502   }
76503   arg2 = *argp2;
76504   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76505   if (!argp3) {
76506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76507     return 0;
76508   }
76509   arg3 = *argp3;
76510   {
76511     try {
76512       result = (bool)(arg1)->AddChild(arg2,arg3);
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76524       };
76525     }
76526   }
76527   jresult = result;
76528   return jresult;
76529 }
76530
76531
76532 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_GetChildAt(void * jarg1, void * jarg2) {
76533   void * jresult ;
76534   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76535   Dali::Toolkit::TableView::CellPosition arg2 ;
76536   Dali::Toolkit::TableView::CellPosition *argp2 ;
76537   Dali::Actor result;
76538
76539   arg1 = (Dali::Toolkit::TableView *)jarg1;
76540   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76541   if (!argp2) {
76542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76543     return 0;
76544   }
76545   arg2 = *argp2;
76546   {
76547     try {
76548       result = (arg1)->GetChildAt(arg2);
76549     } catch (std::out_of_range& e) {
76550       {
76551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76552       };
76553     } catch (std::exception& e) {
76554       {
76555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76560       };
76561     }
76562   }
76563   jresult = new Dali::Actor((const Dali::Actor &)result);
76564   return jresult;
76565 }
76566
76567
76568 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76569   void * jresult ;
76570   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76571   Dali::Toolkit::TableView::CellPosition arg2 ;
76572   Dali::Toolkit::TableView::CellPosition *argp2 ;
76573   Dali::Actor result;
76574
76575   arg1 = (Dali::Toolkit::TableView *)jarg1;
76576   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76577   if (!argp2) {
76578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76579     return 0;
76580   }
76581   arg2 = *argp2;
76582   {
76583     try {
76584       result = (arg1)->RemoveChildAt(arg2);
76585     } catch (std::out_of_range& e) {
76586       {
76587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76588       };
76589     } catch (std::exception& e) {
76590       {
76591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76592       };
76593     } catch (...) {
76594       {
76595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76596       };
76597     }
76598   }
76599   jresult = new Dali::Actor((const Dali::Actor &)result);
76600   return jresult;
76601 }
76602
76603
76604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76605   unsigned int jresult ;
76606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76607   Dali::Actor arg2 ;
76608   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76609   Dali::Actor *argp2 ;
76610   bool result;
76611
76612   arg1 = (Dali::Toolkit::TableView *)jarg1;
76613   argp2 = (Dali::Actor *)jarg2;
76614   if (!argp2) {
76615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76616     return 0;
76617   }
76618   arg2 = *argp2;
76619   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76620   if (!arg3) {
76621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76622     return 0;
76623   }
76624   {
76625     try {
76626       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76627     } catch (std::out_of_range& e) {
76628       {
76629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76630       };
76631     } catch (std::exception& e) {
76632       {
76633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76634       };
76635     } catch (...) {
76636       {
76637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76638       };
76639     }
76640   }
76641   jresult = result;
76642   return jresult;
76643 }
76644
76645
76646 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76647   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76648   unsigned int arg2 ;
76649
76650   arg1 = (Dali::Toolkit::TableView *)jarg1;
76651   arg2 = (unsigned int)jarg2;
76652   {
76653     try {
76654       (arg1)->InsertRow(arg2);
76655     } catch (std::out_of_range& e) {
76656       {
76657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76658       };
76659     } catch (std::exception& e) {
76660       {
76661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76662       };
76663     } catch (...) {
76664       {
76665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76666       };
76667     }
76668   }
76669 }
76670
76671
76672 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76673   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76674   unsigned int arg2 ;
76675
76676   arg1 = (Dali::Toolkit::TableView *)jarg1;
76677   arg2 = (unsigned int)jarg2;
76678   {
76679     try {
76680       (arg1)->DeleteRow(arg2);
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76688       };
76689     } catch (...) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76692       };
76693     }
76694   }
76695 }
76696
76697
76698 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76699   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76700   unsigned int arg2 ;
76701   std::vector< Dali::Actor > *arg3 = 0 ;
76702
76703   arg1 = (Dali::Toolkit::TableView *)jarg1;
76704   arg2 = (unsigned int)jarg2;
76705   arg3 = (std::vector< Dali::Actor > *)jarg3;
76706   if (!arg3) {
76707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76708     return ;
76709   }
76710   {
76711     try {
76712       (arg1)->DeleteRow(arg2,*arg3);
76713     } catch (std::out_of_range& e) {
76714       {
76715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76716       };
76717     } catch (std::exception& e) {
76718       {
76719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76720       };
76721     } catch (...) {
76722       {
76723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76724       };
76725     }
76726   }
76727 }
76728
76729
76730 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76731   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76732   unsigned int arg2 ;
76733
76734   arg1 = (Dali::Toolkit::TableView *)jarg1;
76735   arg2 = (unsigned int)jarg2;
76736   {
76737     try {
76738       (arg1)->InsertColumn(arg2);
76739     } catch (std::out_of_range& e) {
76740       {
76741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76742       };
76743     } catch (std::exception& e) {
76744       {
76745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76746       };
76747     } catch (...) {
76748       {
76749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76750       };
76751     }
76752   }
76753 }
76754
76755
76756 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76757   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76758   unsigned int arg2 ;
76759
76760   arg1 = (Dali::Toolkit::TableView *)jarg1;
76761   arg2 = (unsigned int)jarg2;
76762   {
76763     try {
76764       (arg1)->DeleteColumn(arg2);
76765     } catch (std::out_of_range& e) {
76766       {
76767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76768       };
76769     } catch (std::exception& e) {
76770       {
76771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76772       };
76773     } catch (...) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76776       };
76777     }
76778   }
76779 }
76780
76781
76782 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76783   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76784   unsigned int arg2 ;
76785   std::vector< Dali::Actor > *arg3 = 0 ;
76786
76787   arg1 = (Dali::Toolkit::TableView *)jarg1;
76788   arg2 = (unsigned int)jarg2;
76789   arg3 = (std::vector< Dali::Actor > *)jarg3;
76790   if (!arg3) {
76791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76792     return ;
76793   }
76794   {
76795     try {
76796       (arg1)->DeleteColumn(arg2,*arg3);
76797     } catch (std::out_of_range& e) {
76798       {
76799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76800       };
76801     } catch (std::exception& e) {
76802       {
76803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76804       };
76805     } catch (...) {
76806       {
76807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76808       };
76809     }
76810   }
76811 }
76812
76813
76814 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76815   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76816   unsigned int arg2 ;
76817   unsigned int arg3 ;
76818
76819   arg1 = (Dali::Toolkit::TableView *)jarg1;
76820   arg2 = (unsigned int)jarg2;
76821   arg3 = (unsigned int)jarg3;
76822   {
76823     try {
76824       (arg1)->Resize(arg2,arg3);
76825     } catch (std::out_of_range& e) {
76826       {
76827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76828       };
76829     } catch (std::exception& e) {
76830       {
76831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76832       };
76833     } catch (...) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76836       };
76837     }
76838   }
76839 }
76840
76841
76842 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76843   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76844   unsigned int arg2 ;
76845   unsigned int arg3 ;
76846   std::vector< Dali::Actor > *arg4 = 0 ;
76847
76848   arg1 = (Dali::Toolkit::TableView *)jarg1;
76849   arg2 = (unsigned int)jarg2;
76850   arg3 = (unsigned int)jarg3;
76851   arg4 = (std::vector< Dali::Actor > *)jarg4;
76852   if (!arg4) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76854     return ;
76855   }
76856   {
76857     try {
76858       (arg1)->Resize(arg2,arg3,*arg4);
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76870       };
76871     }
76872   }
76873 }
76874
76875
76876 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76877   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76878   Dali::Size arg2 ;
76879   Dali::Size *argp2 ;
76880
76881   arg1 = (Dali::Toolkit::TableView *)jarg1;
76882   argp2 = (Dali::Size *)jarg2;
76883   if (!argp2) {
76884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76885     return ;
76886   }
76887   arg2 = *argp2;
76888   {
76889     try {
76890       (arg1)->SetCellPadding(arg2);
76891     } catch (std::out_of_range& e) {
76892       {
76893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76894       };
76895     } catch (std::exception& e) {
76896       {
76897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76898       };
76899     } catch (...) {
76900       {
76901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76902       };
76903     }
76904   }
76905 }
76906
76907
76908 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_GetCellPadding(void * jarg1) {
76909   void * jresult ;
76910   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76911   Dali::Size result;
76912
76913   arg1 = (Dali::Toolkit::TableView *)jarg1;
76914   {
76915     try {
76916       result = (arg1)->GetCellPadding();
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76924       };
76925     } catch (...) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76928       };
76929     }
76930   }
76931   jresult = new Dali::Size((const Dali::Size &)result);
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76938   unsigned int arg2 ;
76939
76940   arg1 = (Dali::Toolkit::TableView *)jarg1;
76941   arg2 = (unsigned int)jarg2;
76942   {
76943     try {
76944       (arg1)->SetFitHeight(arg2);
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 unsigned int SWIGSTDCALL CSharp_NUI_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76963   unsigned int jresult ;
76964   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76965   unsigned int arg2 ;
76966   bool result;
76967
76968   arg1 = (Dali::Toolkit::TableView *)jarg1;
76969   arg2 = (unsigned int)jarg2;
76970   {
76971     try {
76972       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76973     } catch (std::out_of_range& e) {
76974       {
76975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76976       };
76977     } catch (std::exception& e) {
76978       {
76979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76980       };
76981     } catch (...) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76984       };
76985     }
76986   }
76987   jresult = result;
76988   return jresult;
76989 }
76990
76991
76992 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76994   unsigned int arg2 ;
76995
76996   arg1 = (Dali::Toolkit::TableView *)jarg1;
76997   arg2 = (unsigned int)jarg2;
76998   {
76999     try {
77000       (arg1)->SetFitWidth(arg2);
77001     } catch (std::out_of_range& e) {
77002       {
77003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77004       };
77005     } catch (std::exception& e) {
77006       {
77007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77008       };
77009     } catch (...) {
77010       {
77011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77012       };
77013     }
77014   }
77015 }
77016
77017
77018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77019   unsigned int jresult ;
77020   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77021   unsigned int arg2 ;
77022   bool result;
77023
77024   arg1 = (Dali::Toolkit::TableView *)jarg1;
77025   arg2 = (unsigned int)jarg2;
77026   {
77027     try {
77028       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77029     } catch (std::out_of_range& e) {
77030       {
77031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77032       };
77033     } catch (std::exception& e) {
77034       {
77035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77036       };
77037     } catch (...) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77040       };
77041     }
77042   }
77043   jresult = result;
77044   return jresult;
77045 }
77046
77047
77048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77049   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77050   unsigned int arg2 ;
77051   float arg3 ;
77052
77053   arg1 = (Dali::Toolkit::TableView *)jarg1;
77054   arg2 = (unsigned int)jarg2;
77055   arg3 = (float)jarg3;
77056   {
77057     try {
77058       (arg1)->SetFixedHeight(arg2,arg3);
77059     } catch (std::out_of_range& e) {
77060       {
77061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77062       };
77063     } catch (std::exception& e) {
77064       {
77065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77066       };
77067     } catch (...) {
77068       {
77069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77070       };
77071     }
77072   }
77073 }
77074
77075
77076 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77077   float jresult ;
77078   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77079   unsigned int arg2 ;
77080   float result;
77081
77082   arg1 = (Dali::Toolkit::TableView *)jarg1;
77083   arg2 = (unsigned int)jarg2;
77084   {
77085     try {
77086       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77087     } catch (std::out_of_range& e) {
77088       {
77089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77090       };
77091     } catch (std::exception& e) {
77092       {
77093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77098       };
77099     }
77100   }
77101   jresult = result;
77102   return jresult;
77103 }
77104
77105
77106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77107   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77108   unsigned int arg2 ;
77109   float arg3 ;
77110
77111   arg1 = (Dali::Toolkit::TableView *)jarg1;
77112   arg2 = (unsigned int)jarg2;
77113   arg3 = (float)jarg3;
77114   {
77115     try {
77116       (arg1)->SetRelativeHeight(arg2,arg3);
77117     } catch (std::out_of_range& e) {
77118       {
77119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77120       };
77121     } catch (std::exception& e) {
77122       {
77123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77124       };
77125     } catch (...) {
77126       {
77127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77128       };
77129     }
77130   }
77131 }
77132
77133
77134 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77135   float jresult ;
77136   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77137   unsigned int arg2 ;
77138   float result;
77139
77140   arg1 = (Dali::Toolkit::TableView *)jarg1;
77141   arg2 = (unsigned int)jarg2;
77142   {
77143     try {
77144       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77145     } catch (std::out_of_range& e) {
77146       {
77147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77148       };
77149     } catch (std::exception& e) {
77150       {
77151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77152       };
77153     } catch (...) {
77154       {
77155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77156       };
77157     }
77158   }
77159   jresult = result;
77160   return jresult;
77161 }
77162
77163
77164 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77165   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77166   unsigned int arg2 ;
77167   float arg3 ;
77168
77169   arg1 = (Dali::Toolkit::TableView *)jarg1;
77170   arg2 = (unsigned int)jarg2;
77171   arg3 = (float)jarg3;
77172   {
77173     try {
77174       (arg1)->SetFixedWidth(arg2,arg3);
77175     } catch (std::out_of_range& e) {
77176       {
77177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77178       };
77179     } catch (std::exception& e) {
77180       {
77181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77182       };
77183     } catch (...) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77186       };
77187     }
77188   }
77189 }
77190
77191
77192 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77193   float jresult ;
77194   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77195   unsigned int arg2 ;
77196   float result;
77197
77198   arg1 = (Dali::Toolkit::TableView *)jarg1;
77199   arg2 = (unsigned int)jarg2;
77200   {
77201     try {
77202       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77210       };
77211     } catch (...) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77214       };
77215     }
77216   }
77217   jresult = result;
77218   return jresult;
77219 }
77220
77221
77222 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77223   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77224   unsigned int arg2 ;
77225   float arg3 ;
77226
77227   arg1 = (Dali::Toolkit::TableView *)jarg1;
77228   arg2 = (unsigned int)jarg2;
77229   arg3 = (float)jarg3;
77230   {
77231     try {
77232       (arg1)->SetRelativeWidth(arg2,arg3);
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 float SWIGSTDCALL CSharp_NUI_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77251   float jresult ;
77252   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77253   unsigned int arg2 ;
77254   float result;
77255
77256   arg1 = (Dali::Toolkit::TableView *)jarg1;
77257   arg2 = (unsigned int)jarg2;
77258   {
77259     try {
77260       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(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 unsigned int SWIGSTDCALL CSharp_NUI_TableView_GetRows(void * jarg1) {
77281   unsigned int jresult ;
77282   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77283   unsigned int result;
77284
77285   arg1 = (Dali::Toolkit::TableView *)jarg1;
77286   {
77287     try {
77288       result = (unsigned int)(arg1)->GetRows();
77289     } catch (std::out_of_range& e) {
77290       {
77291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77292       };
77293     } catch (std::exception& e) {
77294       {
77295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77296       };
77297     } catch (...) {
77298       {
77299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77300       };
77301     }
77302   }
77303   jresult = result;
77304   return jresult;
77305 }
77306
77307
77308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_GetColumns(void * jarg1) {
77309   unsigned int jresult ;
77310   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77311   unsigned int result;
77312
77313   arg1 = (Dali::Toolkit::TableView *)jarg1;
77314   {
77315     try {
77316       result = (unsigned int)(arg1)->GetColumns();
77317     } catch (std::out_of_range& e) {
77318       {
77319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77320       };
77321     } catch (std::exception& e) {
77322       {
77323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77324       };
77325     } catch (...) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77328       };
77329     }
77330   }
77331   jresult = result;
77332   return jresult;
77333 }
77334
77335
77336 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77337   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77338   Dali::Toolkit::TableView::CellPosition arg2 ;
77339   Dali::HorizontalAlignment::Type arg3 ;
77340   Dali::VerticalAlignment::Type arg4 ;
77341   Dali::Toolkit::TableView::CellPosition *argp2 ;
77342
77343   arg1 = (Dali::Toolkit::TableView *)jarg1;
77344   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77345   if (!argp2) {
77346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77347     return ;
77348   }
77349   arg2 = *argp2;
77350   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77351   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77352   {
77353     try {
77354       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77355     } catch (std::out_of_range& e) {
77356       {
77357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77358       };
77359     } catch (std::exception& e) {
77360       {
77361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77362       };
77363     } catch (...) {
77364       {
77365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77366       };
77367     }
77368   }
77369 }
77370
77371
77372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DEFAULT_RENDERING_BACKEND_get() {
77373   unsigned int jresult ;
77374   unsigned int result;
77375
77376   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77377   jresult = result;
77378   return jresult;
77379 }
77380
77381
77382 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_RENDERING_BACKEND_get() {
77383   int jresult ;
77384   int result;
77385
77386   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77387   jresult = (int)result;
77388   return jresult;
77389 }
77390
77391
77392 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_TEXT_get() {
77393   int jresult ;
77394   int result;
77395
77396   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77397   jresult = (int)result;
77398   return jresult;
77399 }
77400
77401
77402 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_TEXT_COLOR_get() {
77403   int jresult ;
77404   int result;
77405
77406   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77407   jresult = (int)result;
77408   return jresult;
77409 }
77410
77411
77412 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_FONT_FAMILY_get() {
77413   int jresult ;
77414   int result;
77415
77416   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77417   jresult = (int)result;
77418   return jresult;
77419 }
77420
77421
77422 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_FONT_STYLE_get() {
77423   int jresult ;
77424   int result;
77425
77426   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77427   jresult = (int)result;
77428   return jresult;
77429 }
77430
77431
77432 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_POINT_SIZE_get() {
77433   int jresult ;
77434   int result;
77435
77436   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77437   jresult = (int)result;
77438   return jresult;
77439 }
77440
77441
77442 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77443   int jresult ;
77444   int result;
77445
77446   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77447   jresult = (int)result;
77448   return jresult;
77449 }
77450
77451
77452 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SCROLL_THRESHOLD_get() {
77453   int jresult ;
77454   int result;
77455
77456   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77457   jresult = (int)result;
77458   return jresult;
77459 }
77460
77461
77462 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SCROLL_SPEED_get() {
77463   int jresult ;
77464   int result;
77465
77466   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77467   jresult = (int)result;
77468   return jresult;
77469 }
77470
77471
77472 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77473   int jresult ;
77474   int result;
77475
77476   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77477   jresult = (int)result;
77478   return jresult;
77479 }
77480
77481
77482 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77483   int jresult ;
77484   int result;
77485
77486   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77487   jresult = (int)result;
77488   return jresult;
77489 }
77490
77491
77492 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77493   int jresult ;
77494   int result;
77495
77496   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77497   jresult = (int)result;
77498   return jresult;
77499 }
77500
77501
77502 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77503   int jresult ;
77504   int result;
77505
77506   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77507   jresult = (int)result;
77508   return jresult;
77509 }
77510
77511
77512 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77513   int jresult ;
77514   int result;
77515
77516   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77517   jresult = (int)result;
77518   return jresult;
77519 }
77520
77521
77522 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_WIDTH_get() {
77523   int jresult ;
77524   int result;
77525
77526   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77527   jresult = (int)result;
77528   return jresult;
77529 }
77530
77531
77532 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77533   int jresult ;
77534   int result;
77535
77536   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77537   jresult = (int)result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77543   int jresult ;
77544   int result;
77545
77546   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77547   jresult = (int)result;
77548   return jresult;
77549 }
77550
77551
77552 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77553   int jresult ;
77554   int result;
77555
77556   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77557   jresult = (int)result;
77558   return jresult;
77559 }
77560
77561
77562 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77563   int jresult ;
77564   int result;
77565
77566   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77567   jresult = (int)result;
77568   return jresult;
77569 }
77570
77571
77572 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77573   int jresult ;
77574   int result;
77575
77576   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77577   jresult = (int)result;
77578   return jresult;
77579 }
77580
77581
77582 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77583   int jresult ;
77584   int result;
77585
77586   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77587   jresult = (int)result;
77588   return jresult;
77589 }
77590
77591
77592 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77593   int jresult ;
77594   int result;
77595
77596   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77597   jresult = (int)result;
77598   return jresult;
77599 }
77600
77601
77602 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77603   int jresult ;
77604   int result;
77605
77606   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77607   jresult = (int)result;
77608   return jresult;
77609 }
77610
77611
77612 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77613   int jresult ;
77614   int result;
77615
77616   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77617   jresult = (int)result;
77618   return jresult;
77619 }
77620
77621
77622 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77623   int jresult ;
77624   int result;
77625
77626   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77627   jresult = (int)result;
77628   return jresult;
77629 }
77630
77631
77632 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_ENABLE_MARKUP_get() {
77633   int jresult ;
77634   int result;
77635
77636   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77637   jresult = (int)result;
77638   return jresult;
77639 }
77640
77641
77642 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_COLOR_get() {
77643   int jresult ;
77644   int result;
77645
77646   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77647   jresult = (int)result;
77648   return jresult;
77649 }
77650
77651
77652 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77653   int jresult ;
77654   int result;
77655
77656   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77657   jresult = (int)result;
77658   return jresult;
77659 }
77660
77661
77662 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_FONT_STYLE_get() {
77663   int jresult ;
77664   int result;
77665
77666   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77667   jresult = (int)result;
77668   return jresult;
77669 }
77670
77671
77672 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_POINT_SIZE_get() {
77673   int jresult ;
77674   int result;
77675
77676   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77677   jresult = (int)result;
77678   return jresult;
77679 }
77680
77681
77682 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_LINE_SPACING_get() {
77683   int jresult ;
77684   int result;
77685
77686   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77687   jresult = (int)result;
77688   return jresult;
77689 }
77690
77691
77692 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_LINE_SPACING_get() {
77693   int jresult ;
77694   int result;
77695
77696   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77697   jresult = (int)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_UNDERLINE_get() {
77703   int jresult ;
77704   int result;
77705
77706   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77707   jresult = (int)result;
77708   return jresult;
77709 }
77710
77711
77712 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_UNDERLINE_get() {
77713   int jresult ;
77714   int result;
77715
77716   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77717   jresult = (int)result;
77718   return jresult;
77719 }
77720
77721
77722 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SHADOW_get() {
77723   int jresult ;
77724   int result;
77725
77726   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77727   jresult = (int)result;
77728   return jresult;
77729 }
77730
77731
77732 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_SHADOW_get() {
77733   int jresult ;
77734   int result;
77735
77736   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77737   jresult = (int)result;
77738   return jresult;
77739 }
77740
77741
77742 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_EMBOSS_get() {
77743   int jresult ;
77744   int result;
77745
77746   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77747   jresult = (int)result;
77748   return jresult;
77749 }
77750
77751
77752 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_EMBOSS_get() {
77753   int jresult ;
77754   int result;
77755
77756   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77757   jresult = (int)result;
77758   return jresult;
77759 }
77760
77761
77762 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_OUTLINE_get() {
77763   int jresult ;
77764   int result;
77765
77766   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77767   jresult = (int)result;
77768   return jresult;
77769 }
77770
77771
77772 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_OUTLINE_get() {
77773   int jresult ;
77774   int result;
77775
77776   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77777   jresult = (int)result;
77778   return jresult;
77779 }
77780
77781
77782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor_Property() {
77783   void * jresult ;
77784   Dali::Toolkit::TextEditor::Property *result = 0 ;
77785
77786   {
77787     try {
77788       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77789     } catch (std::out_of_range& e) {
77790       {
77791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77792       };
77793     } catch (std::exception& e) {
77794       {
77795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77796       };
77797     } catch (...) {
77798       {
77799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77800       };
77801     }
77802   }
77803   jresult = (void *)result;
77804   return jresult;
77805 }
77806
77807
77808 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor_Property(void * jarg1) {
77809   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77810
77811   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77812   {
77813     try {
77814       delete arg1;
77815     } catch (std::out_of_range& e) {
77816       {
77817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77818       };
77819     } catch (std::exception& e) {
77820       {
77821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77822       };
77823     } catch (...) {
77824       {
77825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77826       };
77827     }
77828   }
77829 }
77830
77831
77832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor_InputStyle() {
77833   void * jresult ;
77834   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77835
77836   {
77837     try {
77838       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77839     } catch (std::out_of_range& e) {
77840       {
77841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77842       };
77843     } catch (std::exception& e) {
77844       {
77845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77846       };
77847     } catch (...) {
77848       {
77849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77850       };
77851     }
77852   }
77853   jresult = (void *)result;
77854   return jresult;
77855 }
77856
77857
77858 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor_InputStyle(void * jarg1) {
77859   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77860
77861   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77862   {
77863     try {
77864       delete arg1;
77865     } catch (std::out_of_range& e) {
77866       {
77867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77868       };
77869     } catch (std::exception& e) {
77870       {
77871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77872       };
77873     } catch (...) {
77874       {
77875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77876       };
77877     }
77878   }
77879 }
77880
77881
77882 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_New() {
77883   void * jresult ;
77884   Dali::Toolkit::TextEditor result;
77885
77886   {
77887     try {
77888       result = Dali::Toolkit::TextEditor::New();
77889     } catch (std::out_of_range& e) {
77890       {
77891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77892       };
77893     } catch (std::exception& e) {
77894       {
77895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77896       };
77897     } catch (...) {
77898       {
77899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77900       };
77901     }
77902   }
77903   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77904   return jresult;
77905 }
77906
77907
77908 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor__SWIG_0() {
77909   void * jresult ;
77910   Dali::Toolkit::TextEditor *result = 0 ;
77911
77912   {
77913     try {
77914       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77915     } catch (std::out_of_range& e) {
77916       {
77917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77918       };
77919     } catch (std::exception& e) {
77920       {
77921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (...) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77926       };
77927     }
77928   }
77929   jresult = (void *)result;
77930   return jresult;
77931 }
77932
77933
77934 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor__SWIG_1(void * jarg1) {
77935   void * jresult ;
77936   Dali::Toolkit::TextEditor *arg1 = 0 ;
77937   Dali::Toolkit::TextEditor *result = 0 ;
77938
77939   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77940   if (!arg1) {
77941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77942     return 0;
77943   }
77944   {
77945     try {
77946       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77947     } catch (std::out_of_range& e) {
77948       {
77949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77950       };
77951     } catch (std::exception& e) {
77952       {
77953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77954       };
77955     } catch (...) {
77956       {
77957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77958       };
77959     }
77960   }
77961   jresult = (void *)result;
77962   return jresult;
77963 }
77964
77965
77966 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_Assign(void * jarg1, void * jarg2) {
77967   void * jresult ;
77968   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77969   Dali::Toolkit::TextEditor *arg2 = 0 ;
77970   Dali::Toolkit::TextEditor *result = 0 ;
77971
77972   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77973   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77974   if (!arg2) {
77975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77976     return 0;
77977   }
77978   {
77979     try {
77980       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77981     } catch (std::out_of_range& e) {
77982       {
77983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77984       };
77985     } catch (std::exception& e) {
77986       {
77987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77988       };
77989     } catch (...) {
77990       {
77991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77992       };
77993     }
77994   }
77995   jresult = (void *)result;
77996   return jresult;
77997 }
77998
77999
78000 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor(void * jarg1) {
78001   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78002
78003   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78004   {
78005     try {
78006       delete arg1;
78007     } catch (std::out_of_range& e) {
78008       {
78009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78010       };
78011     } catch (std::exception& e) {
78012       {
78013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78018       };
78019     }
78020   }
78021 }
78022
78023
78024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_DownCast(void * jarg1) {
78025   void * jresult ;
78026   Dali::BaseHandle arg1 ;
78027   Dali::BaseHandle *argp1 ;
78028   Dali::Toolkit::TextEditor result;
78029
78030   argp1 = (Dali::BaseHandle *)jarg1;
78031   if (!argp1) {
78032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78033     return 0;
78034   }
78035   arg1 = *argp1;
78036   {
78037     try {
78038       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78039     } catch (std::out_of_range& e) {
78040       {
78041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78042       };
78043     } catch (std::exception& e) {
78044       {
78045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78046       };
78047     } catch (...) {
78048       {
78049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78050       };
78051     }
78052   }
78053   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_TextChangedSignal(void * jarg1) {
78059   void * jresult ;
78060   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78061   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78062
78063   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78064   {
78065     try {
78066       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78067     } catch (std::out_of_range& e) {
78068       {
78069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78070       };
78071     } catch (std::exception& e) {
78072       {
78073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78074       };
78075     } catch (...) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78078       };
78079     }
78080   }
78081   jresult = (void *)result;
78082   return jresult;
78083 }
78084
78085
78086 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_InputStyleChangedSignal(void * jarg1) {
78087   void * jresult ;
78088   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78089   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78090
78091   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78092   {
78093     try {
78094       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78095     } catch (std::out_of_range& e) {
78096       {
78097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78098       };
78099     } catch (std::exception& e) {
78100       {
78101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78102       };
78103     } catch (...) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78106       };
78107     }
78108   }
78109   jresult = (void *)result;
78110   return jresult;
78111 }
78112
78113
78114 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_RENDERING_BACKEND_get() {
78115   int jresult ;
78116   int result;
78117
78118   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78119   jresult = (int)result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_TEXT_get() {
78125   int jresult ;
78126   int result;
78127
78128   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78129   jresult = (int)result;
78130   return jresult;
78131 }
78132
78133
78134 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_get() {
78135   int jresult ;
78136   int result;
78137
78138   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78139   jresult = (int)result;
78140   return jresult;
78141 }
78142
78143
78144 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78145   int jresult ;
78146   int result;
78147
78148   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78149   jresult = (int)result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_FONT_FAMILY_get() {
78155   int jresult ;
78156   int result;
78157
78158   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78159   jresult = (int)result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_FONT_STYLE_get() {
78165   int jresult ;
78166   int result;
78167
78168   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78169   jresult = (int)result;
78170   return jresult;
78171 }
78172
78173
78174 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_POINT_SIZE_get() {
78175   int jresult ;
78176   int result;
78177
78178   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78179   jresult = (int)result;
78180   return jresult;
78181 }
78182
78183
78184 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_MAX_LENGTH_get() {
78185   int jresult ;
78186   int result;
78187
78188   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78189   jresult = (int)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_EXCEED_POLICY_get() {
78195   int jresult ;
78196   int result;
78197
78198   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78199   jresult = (int)result;
78200   return jresult;
78201 }
78202
78203
78204 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78205   int jresult ;
78206   int result;
78207
78208   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78209   jresult = (int)result;
78210   return jresult;
78211 }
78212
78213
78214 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_VERTICAL_ALIGNMENT_get() {
78215   int jresult ;
78216   int result;
78217
78218   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78219   jresult = (int)result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_TEXT_COLOR_get() {
78225   int jresult ;
78226   int result;
78227
78228   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78229   jresult = (int)result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78235   int jresult ;
78236   int result;
78237
78238   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78239   jresult = (int)result;
78240   return jresult;
78241 }
78242
78243
78244 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_OFFSET_get() {
78245   int jresult ;
78246   int result;
78247
78248   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78249   jresult = (int)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_COLOR_get() {
78255   int jresult ;
78256   int result;
78257
78258   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78259   jresult = (int)result;
78260   return jresult;
78261 }
78262
78263
78264 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78265   int jresult ;
78266   int result;
78267
78268   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78269   jresult = (int)result;
78270   return jresult;
78271 }
78272
78273
78274 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78275   int jresult ;
78276   int result;
78277
78278   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78279   jresult = (int)result;
78280   return jresult;
78281 }
78282
78283
78284 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78285   int jresult ;
78286   int result;
78287
78288   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78289   jresult = (int)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78295   int jresult ;
78296   int result;
78297
78298   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78299   jresult = (int)result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_BLINK_DURATION_get() {
78305   int jresult ;
78306   int result;
78307
78308   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78309   jresult = (int)result;
78310   return jresult;
78311 }
78312
78313
78314 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_WIDTH_get() {
78315   int jresult ;
78316   int result;
78317
78318   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78319   jresult = (int)result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78325   int jresult ;
78326   int result;
78327
78328   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78329   jresult = (int)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78335   int jresult ;
78336   int result;
78337
78338   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78339   jresult = (int)result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SCROLL_THRESHOLD_get() {
78345   int jresult ;
78346   int result;
78347
78348   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78349   jresult = (int)result;
78350   return jresult;
78351 }
78352
78353
78354 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SCROLL_SPEED_get() {
78355   int jresult ;
78356   int result;
78357
78358   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78359   jresult = (int)result;
78360   return jresult;
78361 }
78362
78363
78364 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78365   int jresult ;
78366   int result;
78367
78368   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78369   jresult = (int)result;
78370   return jresult;
78371 }
78372
78373
78374 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78375   int jresult ;
78376   int result;
78377
78378   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78379   jresult = (int)result;
78380   return jresult;
78381 }
78382
78383
78384 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78385   int jresult ;
78386   int result;
78387
78388   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78389   jresult = (int)result;
78390   return jresult;
78391 }
78392
78393
78394 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78395   int jresult ;
78396   int result;
78397
78398   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78399   jresult = (int)result;
78400   return jresult;
78401 }
78402
78403
78404 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78405   int jresult ;
78406   int result;
78407
78408   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78409   jresult = (int)result;
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78415   int jresult ;
78416   int result;
78417
78418   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78419   jresult = (int)result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78425   int jresult ;
78426   int result;
78427
78428   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78429   jresult = (int)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78435   int jresult ;
78436   int result;
78437
78438   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78439   jresult = (int)result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78445   int jresult ;
78446   int result;
78447
78448   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78449   jresult = (int)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_COLOR_get() {
78455   int jresult ;
78456   int result;
78457
78458   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78459   jresult = (int)result;
78460   return jresult;
78461 }
78462
78463
78464 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_ENABLE_MARKUP_get() {
78465   int jresult ;
78466   int result;
78467
78468   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78469   jresult = (int)result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_FONT_FAMILY_get() {
78475   int jresult ;
78476   int result;
78477
78478   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78479   jresult = (int)result;
78480   return jresult;
78481 }
78482
78483
78484 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_FONT_STYLE_get() {
78485   int jresult ;
78486   int result;
78487
78488   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78489   jresult = (int)result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_POINT_SIZE_get() {
78495   int jresult ;
78496   int result;
78497
78498   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78499   jresult = (int)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_UNDERLINE_get() {
78505   int jresult ;
78506   int result;
78507
78508   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78509   jresult = (int)result;
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_UNDERLINE_get() {
78515   int jresult ;
78516   int result;
78517
78518   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78519   jresult = (int)result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_get() {
78525   int jresult ;
78526   int result;
78527
78528   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78529   jresult = (int)result;
78530   return jresult;
78531 }
78532
78533
78534 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_SHADOW_get() {
78535   int jresult ;
78536   int result;
78537
78538   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78539   jresult = (int)result;
78540   return jresult;
78541 }
78542
78543
78544 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_EMBOSS_get() {
78545   int jresult ;
78546   int result;
78547
78548   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78549   jresult = (int)result;
78550   return jresult;
78551 }
78552
78553
78554 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_EMBOSS_get() {
78555   int jresult ;
78556   int result;
78557
78558   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78559   jresult = (int)result;
78560   return jresult;
78561 }
78562
78563
78564 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_OUTLINE_get() {
78565   int jresult ;
78566   int result;
78567
78568   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78569   jresult = (int)result;
78570   return jresult;
78571 }
78572
78573
78574 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_OUTLINE_get() {
78575   int jresult ;
78576   int result;
78577
78578   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78579   jresult = (int)result;
78580   return jresult;
78581 }
78582
78583
78584 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField_Property() {
78585   void * jresult ;
78586   Dali::Toolkit::TextField::Property *result = 0 ;
78587
78588   {
78589     try {
78590       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78591     } catch (std::out_of_range& e) {
78592       {
78593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78594       };
78595     } catch (std::exception& e) {
78596       {
78597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78598       };
78599     } catch (...) {
78600       {
78601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78602       };
78603     }
78604   }
78605   jresult = (void *)result;
78606   return jresult;
78607 }
78608
78609
78610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField_Property(void * jarg1) {
78611   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78612
78613   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78614   {
78615     try {
78616       delete arg1;
78617     } catch (std::out_of_range& e) {
78618       {
78619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78620       };
78621     } catch (std::exception& e) {
78622       {
78623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78624       };
78625     } catch (...) {
78626       {
78627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78628       };
78629     }
78630   }
78631 }
78632
78633
78634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField_InputStyle() {
78635   void * jresult ;
78636   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78637
78638   {
78639     try {
78640       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78641     } catch (std::out_of_range& e) {
78642       {
78643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78644       };
78645     } catch (std::exception& e) {
78646       {
78647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78648       };
78649     } catch (...) {
78650       {
78651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78652       };
78653     }
78654   }
78655   jresult = (void *)result;
78656   return jresult;
78657 }
78658
78659
78660 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField_InputStyle(void * jarg1) {
78661   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78662
78663   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78664   {
78665     try {
78666       delete arg1;
78667     } catch (std::out_of_range& e) {
78668       {
78669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78670       };
78671     } catch (std::exception& e) {
78672       {
78673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78674       };
78675     } catch (...) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78678       };
78679     }
78680   }
78681 }
78682
78683
78684 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_New() {
78685   void * jresult ;
78686   Dali::Toolkit::TextField result;
78687
78688   {
78689     try {
78690       result = Dali::Toolkit::TextField::New();
78691     } catch (std::out_of_range& e) {
78692       {
78693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78694       };
78695     } catch (std::exception& e) {
78696       {
78697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78698       };
78699     } catch (...) {
78700       {
78701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78702       };
78703     }
78704   }
78705   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78706   return jresult;
78707 }
78708
78709
78710 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField__SWIG_0() {
78711   void * jresult ;
78712   Dali::Toolkit::TextField *result = 0 ;
78713
78714   {
78715     try {
78716       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78717     } catch (std::out_of_range& e) {
78718       {
78719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (std::exception& e) {
78722       {
78723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (...) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78728       };
78729     }
78730   }
78731   jresult = (void *)result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField__SWIG_1(void * jarg1) {
78737   void * jresult ;
78738   Dali::Toolkit::TextField *arg1 = 0 ;
78739   Dali::Toolkit::TextField *result = 0 ;
78740
78741   arg1 = (Dali::Toolkit::TextField *)jarg1;
78742   if (!arg1) {
78743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78744     return 0;
78745   }
78746   {
78747     try {
78748       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78749     } catch (std::out_of_range& e) {
78750       {
78751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (std::exception& e) {
78754       {
78755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78756       };
78757     } catch (...) {
78758       {
78759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78760       };
78761     }
78762   }
78763   jresult = (void *)result;
78764   return jresult;
78765 }
78766
78767
78768 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_Assign(void * jarg1, void * jarg2) {
78769   void * jresult ;
78770   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78771   Dali::Toolkit::TextField *arg2 = 0 ;
78772   Dali::Toolkit::TextField *result = 0 ;
78773
78774   arg1 = (Dali::Toolkit::TextField *)jarg1;
78775   arg2 = (Dali::Toolkit::TextField *)jarg2;
78776   if (!arg2) {
78777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78778     return 0;
78779   }
78780   {
78781     try {
78782       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78783     } catch (std::out_of_range& e) {
78784       {
78785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78786       };
78787     } catch (std::exception& e) {
78788       {
78789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78790       };
78791     } catch (...) {
78792       {
78793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78794       };
78795     }
78796   }
78797   jresult = (void *)result;
78798   return jresult;
78799 }
78800
78801
78802 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField(void * jarg1) {
78803   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78804
78805   arg1 = (Dali::Toolkit::TextField *)jarg1;
78806   {
78807     try {
78808       delete arg1;
78809     } catch (std::out_of_range& e) {
78810       {
78811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78812       };
78813     } catch (std::exception& e) {
78814       {
78815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78816       };
78817     } catch (...) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78820       };
78821     }
78822   }
78823 }
78824
78825
78826 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_DownCast(void * jarg1) {
78827   void * jresult ;
78828   Dali::BaseHandle arg1 ;
78829   Dali::BaseHandle *argp1 ;
78830   Dali::Toolkit::TextField result;
78831
78832   argp1 = (Dali::BaseHandle *)jarg1;
78833   if (!argp1) {
78834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78835     return 0;
78836   }
78837   arg1 = *argp1;
78838   {
78839     try {
78840       result = Dali::Toolkit::TextField::DownCast(arg1);
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78848       };
78849     } catch (...) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78852       };
78853     }
78854   }
78855   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78856   return jresult;
78857 }
78858
78859
78860 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_TextChangedSignal(void * jarg1) {
78861   void * jresult ;
78862   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78863   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78864
78865   arg1 = (Dali::Toolkit::TextField *)jarg1;
78866   {
78867     try {
78868       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78869     } catch (std::out_of_range& e) {
78870       {
78871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78872       };
78873     } catch (std::exception& e) {
78874       {
78875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (...) {
78878       {
78879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78880       };
78881     }
78882   }
78883   jresult = (void *)result;
78884   return jresult;
78885 }
78886
78887
78888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_MaxLengthReachedSignal(void * jarg1) {
78889   void * jresult ;
78890   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78891   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78892
78893   arg1 = (Dali::Toolkit::TextField *)jarg1;
78894   {
78895     try {
78896       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78897     } catch (std::out_of_range& e) {
78898       {
78899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78900       };
78901     } catch (std::exception& e) {
78902       {
78903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78904       };
78905     } catch (...) {
78906       {
78907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78908       };
78909     }
78910   }
78911   jresult = (void *)result;
78912   return jresult;
78913 }
78914
78915
78916 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_InputStyleChangedSignal(void * jarg1) {
78917   void * jresult ;
78918   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78919   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78920
78921   arg1 = (Dali::Toolkit::TextField *)jarg1;
78922   {
78923     try {
78924       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78925     } catch (std::out_of_range& e) {
78926       {
78927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (std::exception& e) {
78930       {
78931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78932       };
78933     } catch (...) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78936       };
78937     }
78938   }
78939   jresult = (void *)result;
78940   return jresult;
78941 }
78942
78943
78944 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_RENDERING_BACKEND_get() {
78945   int jresult ;
78946   int result;
78947
78948   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78949   jresult = (int)result;
78950   return jresult;
78951 }
78952
78953
78954 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_TEXT_get() {
78955   int jresult ;
78956   int result;
78957
78958   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78959   jresult = (int)result;
78960   return jresult;
78961 }
78962
78963
78964 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_FONT_FAMILY_get() {
78965   int jresult ;
78966   int result;
78967
78968   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78969   jresult = (int)result;
78970   return jresult;
78971 }
78972
78973
78974 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_FONT_STYLE_get() {
78975   int jresult ;
78976   int result;
78977
78978   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78979   jresult = (int)result;
78980   return jresult;
78981 }
78982
78983
78984 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_POINT_SIZE_get() {
78985   int jresult ;
78986   int result;
78987
78988   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78989   jresult = (int)result;
78990   return jresult;
78991 }
78992
78993
78994 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_MULTI_LINE_get() {
78995   int jresult ;
78996   int result;
78997
78998   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78999   jresult = (int)result;
79000   return jresult;
79001 }
79002
79003
79004 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79005   int jresult ;
79006   int result;
79007
79008   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79009   jresult = (int)result;
79010   return jresult;
79011 }
79012
79013
79014 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79015   int jresult ;
79016   int result;
79017
79018   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79019   jresult = (int)result;
79020   return jresult;
79021 }
79022
79023
79024 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_TEXT_COLOR_get() {
79025   int jresult ;
79026   int result;
79027
79028   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79029   jresult = (int)result;
79030   return jresult;
79031 }
79032
79033
79034 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_OFFSET_get() {
79035   int jresult ;
79036   int result;
79037
79038   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79039   jresult = (int)result;
79040   return jresult;
79041 }
79042
79043
79044 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_COLOR_get() {
79045   int jresult ;
79046   int result;
79047
79048   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79049   jresult = (int)result;
79050   return jresult;
79051 }
79052
79053
79054 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_ENABLED_get() {
79055   int jresult ;
79056   int result;
79057
79058   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79059   jresult = (int)result;
79060   return jresult;
79061 }
79062
79063
79064 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_COLOR_get() {
79065   int jresult ;
79066   int result;
79067
79068   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79069   jresult = (int)result;
79070   return jresult;
79071 }
79072
79073
79074 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79075   int jresult ;
79076   int result;
79077
79078   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79079   jresult = (int)result;
79080   return jresult;
79081 }
79082
79083
79084 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_ENABLE_MARKUP_get() {
79085   int jresult ;
79086   int result;
79087
79088   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79089   jresult = (int)result;
79090   return jresult;
79091 }
79092
79093
79094 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79095   int jresult ;
79096   int result;
79097
79098   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79099   jresult = (int)result;
79100   return jresult;
79101 }
79102
79103
79104 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79105   int jresult ;
79106   int result;
79107
79108   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79109   jresult = (int)result;
79110   return jresult;
79111 }
79112
79113
79114 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79115   int jresult ;
79116   int result;
79117
79118   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79119   jresult = (int)result;
79120   return jresult;
79121 }
79122
79123
79124 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79125   int jresult ;
79126   int result;
79127
79128   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79129   jresult = (int)result;
79130   return jresult;
79131 }
79132
79133
79134 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_LINE_SPACING_get() {
79135   int jresult ;
79136   int result;
79137
79138   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79139   jresult = (int)result;
79140   return jresult;
79141 }
79142
79143
79144 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_get() {
79145   int jresult ;
79146   int result;
79147
79148   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79149   jresult = (int)result;
79150   return jresult;
79151 }
79152
79153
79154 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_get() {
79155   int jresult ;
79156   int result;
79157
79158   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79159   jresult = (int)result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_EMBOSS_get() {
79165   int jresult ;
79166   int result;
79167
79168   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79169   jresult = (int)result;
79170   return jresult;
79171 }
79172
79173
79174 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_OUTLINE_get() {
79175   int jresult ;
79176   int result;
79177
79178   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79179   jresult = (int)result;
79180   return jresult;
79181 }
79182
79183
79184 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel_Property() {
79185   void * jresult ;
79186   Dali::Toolkit::TextLabel::Property *result = 0 ;
79187
79188   {
79189     try {
79190       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79191     } catch (std::out_of_range& e) {
79192       {
79193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79194       };
79195     } catch (std::exception& e) {
79196       {
79197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79198       };
79199     } catch (...) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79202       };
79203     }
79204   }
79205   jresult = (void *)result;
79206   return jresult;
79207 }
79208
79209
79210 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextLabel_Property(void * jarg1) {
79211   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79212
79213   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79214   {
79215     try {
79216       delete arg1;
79217     } catch (std::out_of_range& e) {
79218       {
79219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79220       };
79221     } catch (std::exception& e) {
79222       {
79223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79224       };
79225     } catch (...) {
79226       {
79227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79228       };
79229     }
79230   }
79231 }
79232
79233
79234 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_New__SWIG_0() {
79235   void * jresult ;
79236   Dali::Toolkit::TextLabel result;
79237
79238   {
79239     try {
79240       result = Dali::Toolkit::TextLabel::New();
79241     } catch (std::out_of_range& e) {
79242       {
79243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79244       };
79245     } catch (std::exception& e) {
79246       {
79247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79248       };
79249     } catch (...) {
79250       {
79251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79252       };
79253     }
79254   }
79255   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79256   return jresult;
79257 }
79258
79259
79260 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_New__SWIG_1(char * jarg1) {
79261   void * jresult ;
79262   std::string *arg1 = 0 ;
79263   Dali::Toolkit::TextLabel result;
79264
79265   if (!jarg1) {
79266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79267     return 0;
79268   }
79269   std::string arg1_str(jarg1);
79270   arg1 = &arg1_str;
79271   {
79272     try {
79273       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79274     } catch (std::out_of_range& e) {
79275       {
79276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79277       };
79278     } catch (std::exception& e) {
79279       {
79280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79281       };
79282     } catch (...) {
79283       {
79284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79285       };
79286     }
79287   }
79288   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79289
79290   //argout typemap for const std::string&
79291
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel__SWIG_0() {
79297   void * jresult ;
79298   Dali::Toolkit::TextLabel *result = 0 ;
79299
79300   {
79301     try {
79302       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79303     } catch (std::out_of_range& e) {
79304       {
79305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79306       };
79307     } catch (std::exception& e) {
79308       {
79309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79310       };
79311     } catch (...) {
79312       {
79313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79314       };
79315     }
79316   }
79317   jresult = (void *)result;
79318   return jresult;
79319 }
79320
79321
79322 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel__SWIG_1(void * jarg1) {
79323   void * jresult ;
79324   Dali::Toolkit::TextLabel *arg1 = 0 ;
79325   Dali::Toolkit::TextLabel *result = 0 ;
79326
79327   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79328   if (!arg1) {
79329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79330     return 0;
79331   }
79332   {
79333     try {
79334       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79335     } catch (std::out_of_range& e) {
79336       {
79337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (std::exception& e) {
79340       {
79341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349   jresult = (void *)result;
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_Assign(void * jarg1, void * jarg2) {
79355   void * jresult ;
79356   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79357   Dali::Toolkit::TextLabel *arg2 = 0 ;
79358   Dali::Toolkit::TextLabel *result = 0 ;
79359
79360   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79361   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79362   if (!arg2) {
79363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79364     return 0;
79365   }
79366   {
79367     try {
79368       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79369     } catch (std::out_of_range& e) {
79370       {
79371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79372       };
79373     } catch (std::exception& e) {
79374       {
79375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (...) {
79378       {
79379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79380       };
79381     }
79382   }
79383   jresult = (void *)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextLabel(void * jarg1) {
79389   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79390
79391   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79392   {
79393     try {
79394       delete arg1;
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79402       };
79403     } catch (...) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79406       };
79407     }
79408   }
79409 }
79410
79411
79412 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_DownCast(void * jarg1) {
79413   void * jresult ;
79414   Dali::BaseHandle arg1 ;
79415   Dali::BaseHandle *argp1 ;
79416   Dali::Toolkit::TextLabel result;
79417
79418   argp1 = (Dali::BaseHandle *)jarg1;
79419   if (!argp1) {
79420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79421     return 0;
79422   }
79423   arg1 = *argp1;
79424   {
79425     try {
79426       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79427     } catch (std::out_of_range& e) {
79428       {
79429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79430       };
79431     } catch (std::exception& e) {
79432       {
79433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79434       };
79435     } catch (...) {
79436       {
79437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79438       };
79439     }
79440   }
79441   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79442   return jresult;
79443 }
79444
79445
79446 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityManager() {
79447   void * jresult ;
79448   Dali::Toolkit::AccessibilityManager *result = 0 ;
79449
79450   {
79451     try {
79452       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79453     } catch (std::out_of_range& e) {
79454       {
79455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79456       };
79457     } catch (std::exception& e) {
79458       {
79459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79460       };
79461     } catch (...) {
79462       {
79463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79464       };
79465     }
79466   }
79467   jresult = (void *)result;
79468   return jresult;
79469 }
79470
79471
79472 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityManager(void * jarg1) {
79473   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79474
79475   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79476   {
79477     try {
79478       delete arg1;
79479     } catch (std::out_of_range& e) {
79480       {
79481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79482       };
79483     } catch (std::exception& e) {
79484       {
79485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79486       };
79487     } catch (...) {
79488       {
79489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79490       };
79491     }
79492   }
79493 }
79494
79495
79496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_Get() {
79497   void * jresult ;
79498   Dali::Toolkit::AccessibilityManager result;
79499
79500   {
79501     try {
79502       result = Dali::Toolkit::AccessibilityManager::Get();
79503     } catch (std::out_of_range& e) {
79504       {
79505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79506       };
79507     } catch (std::exception& e) {
79508       {
79509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79510       };
79511     } catch (...) {
79512       {
79513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79514       };
79515     }
79516   }
79517   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79518   return jresult;
79519 }
79520
79521
79522 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79523   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79524   Dali::Actor arg2 ;
79525   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79526   std::string *arg4 = 0 ;
79527   Dali::Actor *argp2 ;
79528
79529   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79530   argp2 = (Dali::Actor *)jarg2;
79531   if (!argp2) {
79532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79533     return ;
79534   }
79535   arg2 = *argp2;
79536   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79537   if (!jarg4) {
79538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79539     return ;
79540   }
79541   std::string arg4_str(jarg4);
79542   arg4 = &arg4_str;
79543   {
79544     try {
79545       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79546     } catch (std::out_of_range& e) {
79547       {
79548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79549       };
79550     } catch (std::exception& e) {
79551       {
79552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79553       };
79554     } catch (...) {
79555       {
79556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79557       };
79558     }
79559   }
79560
79561   //argout typemap for const std::string&
79562
79563 }
79564
79565
79566 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79567   char * jresult ;
79568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79569   Dali::Actor arg2 ;
79570   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79571   Dali::Actor *argp2 ;
79572   std::string result;
79573
79574   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79575   argp2 = (Dali::Actor *)jarg2;
79576   if (!argp2) {
79577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79578     return 0;
79579   }
79580   arg2 = *argp2;
79581   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79582   {
79583     try {
79584       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79585     } catch (std::out_of_range& e) {
79586       {
79587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79588       };
79589     } catch (std::exception& e) {
79590       {
79591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79592       };
79593     } catch (...) {
79594       {
79595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79596       };
79597     }
79598   }
79599   jresult = SWIG_csharp_string_callback((&result)->c_str());
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79605   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79606   Dali::Actor arg2 ;
79607   unsigned int arg3 ;
79608   Dali::Actor *argp2 ;
79609
79610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79611   argp2 = (Dali::Actor *)jarg2;
79612   if (!argp2) {
79613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79614     return ;
79615   }
79616   arg2 = *argp2;
79617   arg3 = (unsigned int)jarg3;
79618   {
79619     try {
79620       (arg1)->SetFocusOrder(arg2,arg3);
79621     } catch (std::out_of_range& e) {
79622       {
79623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79624       };
79625     } catch (std::exception& e) {
79626       {
79627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79628       };
79629     } catch (...) {
79630       {
79631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79632       };
79633     }
79634   }
79635 }
79636
79637
79638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79639   unsigned int jresult ;
79640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79641   Dali::Actor arg2 ;
79642   Dali::Actor *argp2 ;
79643   unsigned int result;
79644
79645   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79646   argp2 = (Dali::Actor *)jarg2;
79647   if (!argp2) {
79648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79649     return 0;
79650   }
79651   arg2 = *argp2;
79652   {
79653     try {
79654       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79655     } catch (std::out_of_range& e) {
79656       {
79657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79658       };
79659     } catch (std::exception& e) {
79660       {
79661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79662       };
79663     } catch (...) {
79664       {
79665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79666       };
79667     }
79668   }
79669   jresult = result;
79670   return jresult;
79671 }
79672
79673
79674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79675   unsigned int jresult ;
79676   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79677   unsigned int result;
79678
79679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79680   {
79681     try {
79682       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79683     } catch (std::out_of_range& e) {
79684       {
79685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79686       };
79687     } catch (std::exception& e) {
79688       {
79689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79690       };
79691     } catch (...) {
79692       {
79693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79694       };
79695     }
79696   }
79697   jresult = result;
79698   return jresult;
79699 }
79700
79701
79702 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79703   void * jresult ;
79704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79705   unsigned int arg2 ;
79706   Dali::Actor result;
79707
79708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79709   arg2 = (unsigned int)jarg2;
79710   {
79711     try {
79712       result = (arg1)->GetActorByFocusOrder(arg2);
79713     } catch (std::out_of_range& e) {
79714       {
79715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79716       };
79717     } catch (std::exception& e) {
79718       {
79719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (...) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79724       };
79725     }
79726   }
79727   jresult = new Dali::Actor((const Dali::Actor &)result);
79728   return jresult;
79729 }
79730
79731
79732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79733   unsigned int jresult ;
79734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79735   Dali::Actor arg2 ;
79736   Dali::Actor *argp2 ;
79737   bool result;
79738
79739   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79740   argp2 = (Dali::Actor *)jarg2;
79741   if (!argp2) {
79742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79743     return 0;
79744   }
79745   arg2 = *argp2;
79746   {
79747     try {
79748       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79749     } catch (std::out_of_range& e) {
79750       {
79751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79752       };
79753     } catch (std::exception& e) {
79754       {
79755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79756       };
79757     } catch (...) {
79758       {
79759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79760       };
79761     }
79762   }
79763   jresult = result;
79764   return jresult;
79765 }
79766
79767
79768 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79769   void * jresult ;
79770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79771   Dali::Actor result;
79772
79773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79774   {
79775     try {
79776       result = (arg1)->GetCurrentFocusActor();
79777     } catch (std::out_of_range& e) {
79778       {
79779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79780       };
79781     } catch (std::exception& e) {
79782       {
79783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (...) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79788       };
79789     }
79790   }
79791   jresult = new Dali::Actor((const Dali::Actor &)result);
79792   return jresult;
79793 }
79794
79795
79796 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79797   void * jresult ;
79798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79799   Dali::Actor result;
79800
79801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79802   {
79803     try {
79804       result = (arg1)->GetCurrentFocusGroup();
79805     } catch (std::out_of_range& e) {
79806       {
79807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79808       };
79809     } catch (std::exception& e) {
79810       {
79811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (...) {
79814       {
79815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79816       };
79817     }
79818   }
79819   jresult = new Dali::Actor((const Dali::Actor &)result);
79820   return jresult;
79821 }
79822
79823
79824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79825   unsigned int jresult ;
79826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79827   unsigned int result;
79828
79829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79830   {
79831     try {
79832       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79833     } catch (std::out_of_range& e) {
79834       {
79835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79836       };
79837     } catch (std::exception& e) {
79838       {
79839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (...) {
79842       {
79843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79844       };
79845     }
79846   }
79847   jresult = result;
79848   return jresult;
79849 }
79850
79851
79852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_MoveFocusForward(void * jarg1) {
79853   unsigned int jresult ;
79854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79855   bool result;
79856
79857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79858   {
79859     try {
79860       result = (bool)(arg1)->MoveFocusForward();
79861     } catch (std::out_of_range& e) {
79862       {
79863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79864       };
79865     } catch (std::exception& e) {
79866       {
79867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79868       };
79869     } catch (...) {
79870       {
79871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79872       };
79873     }
79874   }
79875   jresult = result;
79876   return jresult;
79877 }
79878
79879
79880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79881   unsigned int jresult ;
79882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79883   bool result;
79884
79885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79886   {
79887     try {
79888       result = (bool)(arg1)->MoveFocusBackward();
79889     } catch (std::out_of_range& e) {
79890       {
79891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79892       };
79893     } catch (std::exception& e) {
79894       {
79895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79896       };
79897     } catch (...) {
79898       {
79899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79900       };
79901     }
79902   }
79903   jresult = result;
79904   return jresult;
79905 }
79906
79907
79908 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_ClearFocus(void * jarg1) {
79909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79910
79911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79912   {
79913     try {
79914       (arg1)->ClearFocus();
79915     } catch (std::out_of_range& e) {
79916       {
79917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79918       };
79919     } catch (std::exception& e) {
79920       {
79921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79922       };
79923     } catch (...) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79926       };
79927     }
79928   }
79929 }
79930
79931
79932 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_Reset(void * jarg1) {
79933   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79934
79935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79936   {
79937     try {
79938       (arg1)->Reset();
79939     } catch (std::out_of_range& e) {
79940       {
79941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79942       };
79943     } catch (std::exception& e) {
79944       {
79945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79946       };
79947     } catch (...) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79950       };
79951     }
79952   }
79953 }
79954
79955
79956 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79957   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79958   Dali::Actor arg2 ;
79959   bool arg3 ;
79960   Dali::Actor *argp2 ;
79961
79962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79963   argp2 = (Dali::Actor *)jarg2;
79964   if (!argp2) {
79965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79966     return ;
79967   }
79968   arg2 = *argp2;
79969   arg3 = jarg3 ? true : false;
79970   {
79971     try {
79972       (arg1)->SetFocusGroup(arg2,arg3);
79973     } catch (std::out_of_range& e) {
79974       {
79975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79976       };
79977     } catch (std::exception& e) {
79978       {
79979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79980       };
79981     } catch (...) {
79982       {
79983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79984       };
79985     }
79986   }
79987 }
79988
79989
79990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79991   unsigned int jresult ;
79992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79993   Dali::Actor arg2 ;
79994   Dali::Actor *argp2 ;
79995   bool result;
79996
79997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79998   argp2 = (Dali::Actor *)jarg2;
79999   if (!argp2) {
80000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80001     return 0;
80002   }
80003   arg2 = *argp2;
80004   {
80005     try {
80006       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (...) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80018       };
80019     }
80020   }
80021   jresult = result;
80022   return jresult;
80023 }
80024
80025
80026 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80028   bool arg2 ;
80029
80030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80031   arg2 = jarg2 ? true : false;
80032   {
80033     try {
80034       (arg1)->SetGroupMode(arg2);
80035     } catch (std::out_of_range& e) {
80036       {
80037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80038       };
80039     } catch (std::exception& e) {
80040       {
80041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80042       };
80043     } catch (...) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80046       };
80047     }
80048   }
80049 }
80050
80051
80052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetGroupMode(void * jarg1) {
80053   unsigned int jresult ;
80054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80055   bool result;
80056
80057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80058   {
80059     try {
80060       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80061     } catch (std::out_of_range& e) {
80062       {
80063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80064       };
80065     } catch (std::exception& e) {
80066       {
80067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80072       };
80073     }
80074   }
80075   jresult = result;
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80082   bool arg2 ;
80083
80084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80085   arg2 = jarg2 ? true : false;
80086   {
80087     try {
80088       (arg1)->SetWrapMode(arg2);
80089     } catch (std::out_of_range& e) {
80090       {
80091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80092       };
80093     } catch (std::exception& e) {
80094       {
80095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80096       };
80097     } catch (...) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80100       };
80101     }
80102   }
80103 }
80104
80105
80106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetWrapMode(void * jarg1) {
80107   unsigned int jresult ;
80108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80109   bool result;
80110
80111   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80112   {
80113     try {
80114       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80115     } catch (std::out_of_range& e) {
80116       {
80117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80118       };
80119     } catch (std::exception& e) {
80120       {
80121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80122       };
80123     } catch (...) {
80124       {
80125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80126       };
80127     }
80128   }
80129   jresult = result;
80130   return jresult;
80131 }
80132
80133
80134 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80136   Dali::Actor arg2 ;
80137   Dali::Actor *argp2 ;
80138
80139   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80140   argp2 = (Dali::Actor *)jarg2;
80141   if (!argp2) {
80142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80143     return ;
80144   }
80145   arg2 = *argp2;
80146   {
80147     try {
80148       (arg1)->SetFocusIndicatorActor(arg2);
80149     } catch (std::out_of_range& e) {
80150       {
80151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80152       };
80153     } catch (std::exception& e) {
80154       {
80155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80156       };
80157     } catch (...) {
80158       {
80159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80160       };
80161     }
80162   }
80163 }
80164
80165
80166 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80167   void * jresult ;
80168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80169   Dali::Actor result;
80170
80171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80172   {
80173     try {
80174       result = (arg1)->GetFocusIndicatorActor();
80175     } catch (std::out_of_range& e) {
80176       {
80177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80178       };
80179     } catch (std::exception& e) {
80180       {
80181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80182       };
80183     } catch (...) {
80184       {
80185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80186       };
80187     }
80188   }
80189   jresult = new Dali::Actor((const Dali::Actor &)result);
80190   return jresult;
80191 }
80192
80193
80194 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80195   void * jresult ;
80196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80197   Dali::Actor arg2 ;
80198   Dali::Actor *argp2 ;
80199   Dali::Actor result;
80200
80201   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80202   argp2 = (Dali::Actor *)jarg2;
80203   if (!argp2) {
80204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80205     return 0;
80206   }
80207   arg2 = *argp2;
80208   {
80209     try {
80210       result = (arg1)->GetFocusGroup(arg2);
80211     } catch (std::out_of_range& e) {
80212       {
80213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80214       };
80215     } catch (std::exception& e) {
80216       {
80217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80218       };
80219     } catch (...) {
80220       {
80221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80222       };
80223     }
80224   }
80225   jresult = new Dali::Actor((const Dali::Actor &)result);
80226   return jresult;
80227 }
80228
80229
80230 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetReadPosition(void * jarg1) {
80231   void * jresult ;
80232   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80233   Dali::Vector2 result;
80234
80235   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80236   {
80237     try {
80238       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
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 = new Dali::Vector2((const Dali::Vector2 &)result);
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80259   void * jresult ;
80260   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80261   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80262
80263   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80264   {
80265     try {
80266       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80267     } catch (std::out_of_range& e) {
80268       {
80269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80270       };
80271     } catch (std::exception& e) {
80272       {
80273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80274       };
80275     } catch (...) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80278       };
80279     }
80280   }
80281   jresult = (void *)result;
80282   return jresult;
80283 }
80284
80285
80286 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80287   void * jresult ;
80288   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80289   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80290
80291   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80292   {
80293     try {
80294       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80295     } catch (std::out_of_range& e) {
80296       {
80297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80298       };
80299     } catch (std::exception& e) {
80300       {
80301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80302       };
80303     } catch (...) {
80304       {
80305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80306       };
80307     }
80308   }
80309   jresult = (void *)result;
80310   return jresult;
80311 }
80312
80313
80314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80315   void * jresult ;
80316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80317   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80318
80319   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80320   {
80321     try {
80322       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80323     } catch (std::out_of_range& e) {
80324       {
80325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80326       };
80327     } catch (std::exception& e) {
80328       {
80329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80330       };
80331     } catch (...) {
80332       {
80333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80334       };
80335     }
80336   }
80337   jresult = (void *)result;
80338   return jresult;
80339 }
80340
80341
80342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80343   void * jresult ;
80344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80345   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80346
80347   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80348   {
80349     try {
80350       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80351     } catch (std::out_of_range& e) {
80352       {
80353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80354       };
80355     } catch (std::exception& e) {
80356       {
80357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80358       };
80359     } catch (...) {
80360       {
80361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80362       };
80363     }
80364   }
80365   jresult = (void *)result;
80366   return jresult;
80367 }
80368
80369
80370 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionNextSignal(void * jarg1) {
80371   void * jresult ;
80372   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80373   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80374
80375   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80376   {
80377     try {
80378       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80379     } catch (std::out_of_range& e) {
80380       {
80381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80382       };
80383     } catch (std::exception& e) {
80384       {
80385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80386       };
80387     } catch (...) {
80388       {
80389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80390       };
80391     }
80392   }
80393   jresult = (void *)result;
80394   return jresult;
80395 }
80396
80397
80398 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80399   void * jresult ;
80400   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80401   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80402
80403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80404   {
80405     try {
80406       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
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 = (void *)result;
80422   return jresult;
80423 }
80424
80425
80426 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80427   void * jresult ;
80428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80429   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80430
80431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80432   {
80433     try {
80434       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80435     } catch (std::out_of_range& e) {
80436       {
80437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80438       };
80439     } catch (std::exception& e) {
80440       {
80441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80442       };
80443     } catch (...) {
80444       {
80445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80446       };
80447     }
80448   }
80449   jresult = (void *)result;
80450   return jresult;
80451 }
80452
80453
80454 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadSignal(void * jarg1) {
80455   void * jresult ;
80456   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80457   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80458
80459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80460   {
80461     try {
80462       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80463     } catch (std::out_of_range& e) {
80464       {
80465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80466       };
80467     } catch (std::exception& e) {
80468       {
80469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (...) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80474       };
80475     }
80476   }
80477   jresult = (void *)result;
80478   return jresult;
80479 }
80480
80481
80482 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionOverSignal(void * jarg1) {
80483   void * jresult ;
80484   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80485   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80486
80487   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80488   {
80489     try {
80490       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80491     } catch (std::out_of_range& e) {
80492       {
80493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80494       };
80495     } catch (std::exception& e) {
80496       {
80497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80498       };
80499     } catch (...) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80502       };
80503     }
80504   }
80505   jresult = (void *)result;
80506   return jresult;
80507 }
80508
80509
80510 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80511   void * jresult ;
80512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80513   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80514
80515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80516   {
80517     try {
80518       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80519     } catch (std::out_of_range& e) {
80520       {
80521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80522       };
80523     } catch (std::exception& e) {
80524       {
80525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80526       };
80527     } catch (...) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80530       };
80531     }
80532   }
80533   jresult = (void *)result;
80534   return jresult;
80535 }
80536
80537
80538 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80539   void * jresult ;
80540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80541   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80542
80543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80544   {
80545     try {
80546       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80547     } catch (std::out_of_range& e) {
80548       {
80549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80550       };
80551     } catch (std::exception& e) {
80552       {
80553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80554       };
80555     } catch (...) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80558       };
80559     }
80560   }
80561   jresult = (void *)result;
80562   return jresult;
80563 }
80564
80565
80566 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionUpSignal(void * jarg1) {
80567   void * jresult ;
80568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80569   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80570
80571   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80572   {
80573     try {
80574       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80575     } catch (std::out_of_range& e) {
80576       {
80577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80578       };
80579     } catch (std::exception& e) {
80580       {
80581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80582       };
80583     } catch (...) {
80584       {
80585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80586       };
80587     }
80588   }
80589   jresult = (void *)result;
80590   return jresult;
80591 }
80592
80593
80594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionDownSignal(void * jarg1) {
80595   void * jresult ;
80596   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80597   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80598
80599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80600   {
80601     try {
80602       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80603     } catch (std::out_of_range& e) {
80604       {
80605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80606       };
80607     } catch (std::exception& e) {
80608       {
80609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80610       };
80611     } catch (...) {
80612       {
80613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80614       };
80615     }
80616   }
80617   jresult = (void *)result;
80618   return jresult;
80619 }
80620
80621
80622 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80623   void * jresult ;
80624   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80625   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80626
80627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80628   {
80629     try {
80630       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80631     } catch (std::out_of_range& e) {
80632       {
80633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80634       };
80635     } catch (std::exception& e) {
80636       {
80637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80638       };
80639     } catch (...) {
80640       {
80641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80642       };
80643     }
80644   }
80645   jresult = (void *)result;
80646   return jresult;
80647 }
80648
80649
80650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionBackSignal(void * jarg1) {
80651   void * jresult ;
80652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80653   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80654
80655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80656   {
80657     try {
80658       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80659     } catch (std::out_of_range& e) {
80660       {
80661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80662       };
80663     } catch (std::exception& e) {
80664       {
80665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80666       };
80667     } catch (...) {
80668       {
80669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80670       };
80671     }
80672   }
80673   jresult = (void *)result;
80674   return jresult;
80675 }
80676
80677
80678 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80679   void * jresult ;
80680   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80681   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80682
80683   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80684   {
80685     try {
80686       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80687     } catch (std::out_of_range& e) {
80688       {
80689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80690       };
80691     } catch (std::exception& e) {
80692       {
80693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80694       };
80695     } catch (...) {
80696       {
80697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80698       };
80699     }
80700   }
80701   jresult = (void *)result;
80702   return jresult;
80703 }
80704
80705
80706 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80707   void * jresult ;
80708   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80709   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80710
80711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80712   {
80713     try {
80714       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80715     } catch (std::out_of_range& e) {
80716       {
80717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80718       };
80719     } catch (std::exception& e) {
80720       {
80721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80722       };
80723     } catch (...) {
80724       {
80725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80726       };
80727     }
80728   }
80729   jresult = (void *)result;
80730   return jresult;
80731 }
80732
80733
80734 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80735   void * jresult ;
80736   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80737   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80738
80739   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80740   {
80741     try {
80742       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80743     } catch (std::out_of_range& e) {
80744       {
80745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80746       };
80747     } catch (std::exception& e) {
80748       {
80749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80750       };
80751     } catch (...) {
80752       {
80753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80754       };
80755     }
80756   }
80757   jresult = (void *)result;
80758   return jresult;
80759 }
80760
80761
80762 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80763   void * jresult ;
80764   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80765   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80766
80767   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80768   {
80769     try {
80770       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80771     } catch (std::out_of_range& e) {
80772       {
80773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80774       };
80775     } catch (std::exception& e) {
80776       {
80777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80778       };
80779     } catch (...) {
80780       {
80781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80782       };
80783     }
80784   }
80785   jresult = (void *)result;
80786   return jresult;
80787 }
80788
80789
80790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80791   void * jresult ;
80792   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80793   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80794
80795   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80796   {
80797     try {
80798       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80799     } catch (std::out_of_range& e) {
80800       {
80801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80802       };
80803     } catch (std::exception& e) {
80804       {
80805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80806       };
80807     } catch (...) {
80808       {
80809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80810       };
80811     }
80812   }
80813   jresult = (void *)result;
80814   return jresult;
80815 }
80816
80817
80818 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80819   void * jresult ;
80820   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80821   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80822
80823   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80824   {
80825     try {
80826       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80827     } catch (std::out_of_range& e) {
80828       {
80829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80830       };
80831     } catch (std::exception& e) {
80832       {
80833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80834       };
80835     } catch (...) {
80836       {
80837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80838       };
80839     }
80840   }
80841   jresult = (void *)result;
80842   return jresult;
80843 }
80844
80845
80846 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80847   void * jresult ;
80848   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80849   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80850
80851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80852   {
80853     try {
80854       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (...) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80866       };
80867     }
80868   }
80869   jresult = (void *)result;
80870   return jresult;
80871 }
80872
80873
80874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80875   void * jresult ;
80876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80877   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80878
80879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80880   {
80881     try {
80882       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80883     } catch (std::out_of_range& e) {
80884       {
80885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80886       };
80887     } catch (std::exception& e) {
80888       {
80889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80894       };
80895     }
80896   }
80897   jresult = (void *)result;
80898   return jresult;
80899 }
80900
80901
80902 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80903   void * jresult ;
80904   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80905   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80906
80907   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80908   {
80909     try {
80910       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (...) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80922       };
80923     }
80924   }
80925   jresult = (void *)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80931   void * jresult ;
80932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80933   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80934
80935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80936   {
80937     try {
80938       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80939     } catch (std::out_of_range& e) {
80940       {
80941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (std::exception& e) {
80944       {
80945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (...) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80950       };
80951     }
80952   }
80953   jresult = (void *)result;
80954   return jresult;
80955 }
80956
80957
80958 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80959   void * jresult ;
80960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80961   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80962
80963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80964   {
80965     try {
80966       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80978       };
80979     }
80980   }
80981   jresult = (void *)result;
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80987   void * jresult ;
80988   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80989   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80990
80991   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80992   {
80993     try {
80994       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80995     } catch (std::out_of_range& e) {
80996       {
80997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80998       };
80999     } catch (std::exception& e) {
81000       {
81001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81002       };
81003     } catch (...) {
81004       {
81005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81006       };
81007     }
81008   }
81009   jresult = (void *)result;
81010   return jresult;
81011 }
81012
81013
81014 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81015   void * jresult ;
81016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81017   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81018
81019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81020   {
81021     try {
81022       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81023     } catch (std::out_of_range& e) {
81024       {
81025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81026       };
81027     } catch (std::exception& e) {
81028       {
81029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81030       };
81031     } catch (...) {
81032       {
81033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81034       };
81035     }
81036   }
81037   jresult = (void *)result;
81038   return jresult;
81039 }
81040
81041
81042 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81043   void * jresult ;
81044   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81045   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81046
81047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81048   {
81049     try {
81050       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81051     } catch (std::out_of_range& e) {
81052       {
81053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81054       };
81055     } catch (std::exception& e) {
81056       {
81057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81058       };
81059     } catch (...) {
81060       {
81061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81062       };
81063     }
81064   }
81065   jresult = (void *)result;
81066   return jresult;
81067 }
81068
81069
81070 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81071   void * jresult ;
81072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81073   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81074
81075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81076   {
81077     try {
81078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81079     } catch (std::out_of_range& e) {
81080       {
81081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81082       };
81083     } catch (std::exception& e) {
81084       {
81085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81086       };
81087     } catch (...) {
81088       {
81089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81090       };
81091     }
81092   }
81093   jresult = (void *)result;
81094   return jresult;
81095 }
81096
81097
81098 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StyleManager() {
81099   void * jresult ;
81100   Dali::Toolkit::StyleManager *result = 0 ;
81101
81102   {
81103     try {
81104       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81105     } catch (std::out_of_range& e) {
81106       {
81107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81108       };
81109     } catch (std::exception& e) {
81110       {
81111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81112       };
81113     } catch (...) {
81114       {
81115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81116       };
81117     }
81118   }
81119   jresult = (void *)result;
81120   return jresult;
81121 }
81122
81123
81124 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StyleManager(void * jarg1) {
81125   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81126
81127   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81128   {
81129     try {
81130       delete arg1;
81131     } catch (std::out_of_range& e) {
81132       {
81133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81134       };
81135     } catch (std::exception& e) {
81136       {
81137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81138       };
81139     } catch (...) {
81140       {
81141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81142       };
81143     }
81144   }
81145 }
81146
81147
81148 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StyleManager_Get() {
81149   void * jresult ;
81150   Dali::Toolkit::StyleManager result;
81151
81152   {
81153     try {
81154       result = Dali::Toolkit::StyleManager::Get();
81155     } catch (std::out_of_range& e) {
81156       {
81157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81158       };
81159     } catch (std::exception& e) {
81160       {
81161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81162       };
81163     } catch (...) {
81164       {
81165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81166       };
81167     }
81168   }
81169   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81170   return jresult;
81171 }
81172
81173
81174 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81175   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81176   std::string *arg2 = 0 ;
81177
81178   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81179   if (!jarg2) {
81180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81181     return ;
81182   }
81183   std::string arg2_str(jarg2);
81184   arg2 = &arg2_str;
81185   {
81186     try {
81187       (arg1)->ApplyTheme((std::string const &)*arg2);
81188     } catch (std::out_of_range& e) {
81189       {
81190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81191       };
81192     } catch (std::exception& e) {
81193       {
81194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81199       };
81200     }
81201   }
81202
81203   //argout typemap for const std::string&
81204
81205 }
81206
81207
81208 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyDefaultTheme(void * jarg1) {
81209   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81210
81211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81212   {
81213     try {
81214       (arg1)->ApplyDefaultTheme();
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (...) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81226       };
81227     }
81228   }
81229 }
81230
81231
81232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81233   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81234   std::string *arg2 = 0 ;
81235   Dali::Property::Value *arg3 = 0 ;
81236
81237   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81238   if (!jarg2) {
81239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81240     return ;
81241   }
81242   std::string arg2_str(jarg2);
81243   arg2 = &arg2_str;
81244   arg3 = (Dali::Property::Value *)jarg3;
81245   if (!arg3) {
81246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81247     return ;
81248   }
81249   {
81250     try {
81251       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81252     } catch (std::out_of_range& e) {
81253       {
81254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81255       };
81256     } catch (std::exception& e) {
81257       {
81258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81259       };
81260     } catch (...) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81263       };
81264     }
81265   }
81266
81267   //argout typemap for const std::string&
81268
81269 }
81270
81271
81272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81273   unsigned int jresult ;
81274   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81275   std::string *arg2 = 0 ;
81276   Dali::Property::Value *arg3 = 0 ;
81277   bool result;
81278
81279   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81280   if (!jarg2) {
81281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81282     return 0;
81283   }
81284   std::string arg2_str(jarg2);
81285   arg2 = &arg2_str;
81286   arg3 = (Dali::Property::Value *)jarg3;
81287   if (!arg3) {
81288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81289     return 0;
81290   }
81291   {
81292     try {
81293       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81294     } catch (std::out_of_range& e) {
81295       {
81296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81297       };
81298     } catch (std::exception& e) {
81299       {
81300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81301       };
81302     } catch (...) {
81303       {
81304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81305       };
81306     }
81307   }
81308   jresult = result;
81309
81310   //argout typemap for const std::string&
81311
81312   return jresult;
81313 }
81314
81315
81316 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81317   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81318   Dali::Toolkit::Control arg2 ;
81319   std::string *arg3 = 0 ;
81320   std::string *arg4 = 0 ;
81321   Dali::Toolkit::Control *argp2 ;
81322
81323   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81324   argp2 = (Dali::Toolkit::Control *)jarg2;
81325   if (!argp2) {
81326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81327     return ;
81328   }
81329   arg2 = *argp2;
81330   if (!jarg3) {
81331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81332     return ;
81333   }
81334   std::string arg3_str(jarg3);
81335   arg3 = &arg3_str;
81336   if (!jarg4) {
81337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81338     return ;
81339   }
81340   std::string arg4_str(jarg4);
81341   arg4 = &arg4_str;
81342   {
81343     try {
81344       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81345     } catch (std::out_of_range& e) {
81346       {
81347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81348       };
81349     } catch (std::exception& e) {
81350       {
81351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81352       };
81353     } catch (...) {
81354       {
81355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81356       };
81357     }
81358   }
81359
81360   //argout typemap for const std::string&
81361
81362
81363   //argout typemap for const std::string&
81364
81365 }
81366
81367
81368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StyleManager_StyleChangedSignal(void * jarg1) {
81369   void * jresult ;
81370   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81371   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81372
81373   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81374   {
81375     try {
81376       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391   jresult = (void *)result;
81392   return jresult;
81393 }
81394
81395
81396 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_LOWER_BOUND_get() {
81397   int jresult ;
81398   int result;
81399
81400   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81401   jresult = (int)result;
81402   return jresult;
81403 }
81404
81405
81406 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_UPPER_BOUND_get() {
81407   int jresult ;
81408   int result;
81409
81410   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81411   jresult = (int)result;
81412   return jresult;
81413 }
81414
81415
81416 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_VALUE_get() {
81417   int jresult ;
81418   int result;
81419
81420   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81421   jresult = (int)result;
81422   return jresult;
81423 }
81424
81425
81426 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_TRACK_VISUAL_get() {
81427   int jresult ;
81428   int result;
81429
81430   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81431   jresult = (int)result;
81432   return jresult;
81433 }
81434
81435
81436 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_HANDLE_VISUAL_get() {
81437   int jresult ;
81438   int result;
81439
81440   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81441   jresult = (int)result;
81442   return jresult;
81443 }
81444
81445
81446 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_PROGRESS_VISUAL_get() {
81447   int jresult ;
81448   int result;
81449
81450   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81451   jresult = (int)result;
81452   return jresult;
81453 }
81454
81455
81456 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_POPUP_VISUAL_get() {
81457   int jresult ;
81458   int result;
81459
81460   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81461   jresult = (int)result;
81462   return jresult;
81463 }
81464
81465
81466 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_POPUP_ARROW_VISUAL_get() {
81467   int jresult ;
81468   int result;
81469
81470   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81471   jresult = (int)result;
81472   return jresult;
81473 }
81474
81475
81476 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_DISABLED_COLOR_get() {
81477   int jresult ;
81478   int result;
81479
81480   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81481   jresult = (int)result;
81482   return jresult;
81483 }
81484
81485
81486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_VALUE_PRECISION_get() {
81487   int jresult ;
81488   int result;
81489
81490   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81491   jresult = (int)result;
81492   return jresult;
81493 }
81494
81495
81496 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SHOW_POPUP_get() {
81497   int jresult ;
81498   int result;
81499
81500   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81501   jresult = (int)result;
81502   return jresult;
81503 }
81504
81505
81506 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SHOW_VALUE_get() {
81507   int jresult ;
81508   int result;
81509
81510   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81511   jresult = (int)result;
81512   return jresult;
81513 }
81514
81515
81516 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_MARKS_get() {
81517   int jresult ;
81518   int result;
81519
81520   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81521   jresult = (int)result;
81522   return jresult;
81523 }
81524
81525
81526 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SNAP_TO_MARKS_get() {
81527   int jresult ;
81528   int result;
81529
81530   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81531   jresult = (int)result;
81532   return jresult;
81533 }
81534
81535
81536 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_MARK_TOLERANCE_get() {
81537   int jresult ;
81538   int result;
81539
81540   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81541   jresult = (int)result;
81542   return jresult;
81543 }
81544
81545
81546 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider_Property() {
81547   void * jresult ;
81548   Dali::Toolkit::Slider::Property *result = 0 ;
81549
81550   {
81551     try {
81552       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81553     } catch (std::out_of_range& e) {
81554       {
81555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81556       };
81557     } catch (std::exception& e) {
81558       {
81559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81560       };
81561     } catch (...) {
81562       {
81563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81564       };
81565     }
81566   }
81567   jresult = (void *)result;
81568   return jresult;
81569 }
81570
81571
81572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Slider_Property(void * jarg1) {
81573   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81574
81575   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81576   {
81577     try {
81578       delete arg1;
81579     } catch (std::out_of_range& e) {
81580       {
81581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81582       };
81583     } catch (std::exception& e) {
81584       {
81585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81590       };
81591     }
81592   }
81593 }
81594
81595
81596 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_New() {
81597   void * jresult ;
81598   Dali::Toolkit::Slider result;
81599
81600   {
81601     try {
81602       result = Dali::Toolkit::Slider::New();
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81610       };
81611     } catch (...) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81614       };
81615     }
81616   }
81617   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81618   return jresult;
81619 }
81620
81621
81622 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider__SWIG_0() {
81623   void * jresult ;
81624   Dali::Toolkit::Slider *result = 0 ;
81625
81626   {
81627     try {
81628       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (...) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81640       };
81641     }
81642   }
81643   jresult = (void *)result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider__SWIG_1(void * jarg1) {
81649   void * jresult ;
81650   Dali::Toolkit::Slider *arg1 = 0 ;
81651   Dali::Toolkit::Slider *result = 0 ;
81652
81653   arg1 = (Dali::Toolkit::Slider *)jarg1;
81654   if (!arg1) {
81655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81656     return 0;
81657   }
81658   {
81659     try {
81660       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81661     } catch (std::out_of_range& e) {
81662       {
81663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81664       };
81665     } catch (std::exception& e) {
81666       {
81667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81668       };
81669     } catch (...) {
81670       {
81671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81672       };
81673     }
81674   }
81675   jresult = (void *)result;
81676   return jresult;
81677 }
81678
81679
81680 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_Assign(void * jarg1, void * jarg2) {
81681   void * jresult ;
81682   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81683   Dali::Toolkit::Slider *arg2 = 0 ;
81684   Dali::Toolkit::Slider *result = 0 ;
81685
81686   arg1 = (Dali::Toolkit::Slider *)jarg1;
81687   arg2 = (Dali::Toolkit::Slider *)jarg2;
81688   if (!arg2) {
81689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81690     return 0;
81691   }
81692   {
81693     try {
81694       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81695     } catch (std::out_of_range& e) {
81696       {
81697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81698       };
81699     } catch (std::exception& e) {
81700       {
81701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81702       };
81703     } catch (...) {
81704       {
81705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81706       };
81707     }
81708   }
81709   jresult = (void *)result;
81710   return jresult;
81711 }
81712
81713
81714 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Slider(void * jarg1) {
81715   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81716
81717   arg1 = (Dali::Toolkit::Slider *)jarg1;
81718   {
81719     try {
81720       delete arg1;
81721     } catch (std::out_of_range& e) {
81722       {
81723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81724       };
81725     } catch (std::exception& e) {
81726       {
81727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81728       };
81729     } catch (...) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81732       };
81733     }
81734   }
81735 }
81736
81737
81738 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_DownCast(void * jarg1) {
81739   void * jresult ;
81740   Dali::BaseHandle arg1 ;
81741   Dali::BaseHandle *argp1 ;
81742   Dali::Toolkit::Slider result;
81743
81744   argp1 = (Dali::BaseHandle *)jarg1;
81745   if (!argp1) {
81746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81747     return 0;
81748   }
81749   arg1 = *argp1;
81750   {
81751     try {
81752       result = Dali::Toolkit::Slider::DownCast(arg1);
81753     } catch (std::out_of_range& e) {
81754       {
81755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81756       };
81757     } catch (std::exception& e) {
81758       {
81759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81764       };
81765     }
81766   }
81767   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81768   return jresult;
81769 }
81770
81771
81772 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_ValueChangedSignal(void * jarg1) {
81773   void * jresult ;
81774   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81775   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81776
81777   arg1 = (Dali::Toolkit::Slider *)jarg1;
81778   {
81779     try {
81780       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81781     } catch (std::out_of_range& e) {
81782       {
81783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81784       };
81785     } catch (std::exception& e) {
81786       {
81787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (...) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81792       };
81793     }
81794   }
81795   jresult = (void *)result;
81796   return jresult;
81797 }
81798
81799
81800 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_SlidingFinishedSignal(void * jarg1) {
81801   void * jresult ;
81802   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81803   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81804
81805   arg1 = (Dali::Toolkit::Slider *)jarg1;
81806   {
81807     try {
81808       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81809     } catch (std::out_of_range& e) {
81810       {
81811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81812       };
81813     } catch (std::exception& e) {
81814       {
81815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81816       };
81817     } catch (...) {
81818       {
81819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81820       };
81821     }
81822   }
81823   jresult = (void *)result;
81824   return jresult;
81825 }
81826
81827
81828 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_MarkReachedSignal(void * jarg1) {
81829   void * jresult ;
81830   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81831   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81832
81833   arg1 = (Dali::Toolkit::Slider *)jarg1;
81834   {
81835     try {
81836       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81837     } catch (std::out_of_range& e) {
81838       {
81839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81840       };
81841     } catch (std::exception& e) {
81842       {
81843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81844       };
81845     } catch (...) {
81846       {
81847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81848       };
81849     }
81850   }
81851   jresult = (void *)result;
81852   return jresult;
81853 }
81854
81855
81856 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_VIDEO_get() {
81857   int jresult ;
81858   int result;
81859
81860   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81861   jresult = (int)result;
81862   return jresult;
81863 }
81864
81865
81866 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_LOOPING_get() {
81867   int jresult ;
81868   int result;
81869
81870   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81871   jresult = (int)result;
81872   return jresult;
81873 }
81874
81875
81876 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_MUTED_get() {
81877   int jresult ;
81878   int result;
81879
81880   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81881   jresult = (int)result;
81882   return jresult;
81883 }
81884
81885
81886 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_VOLUME_get() {
81887   int jresult ;
81888   int result;
81889
81890   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81891   jresult = (int)result;
81892   return jresult;
81893 }
81894
81895
81896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView_Property() {
81897   void * jresult ;
81898   Dali::Toolkit::VideoView::Property *result = 0 ;
81899
81900   {
81901     try {
81902       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81903     } catch (std::out_of_range& e) {
81904       {
81905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81906       };
81907     } catch (std::exception& e) {
81908       {
81909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81910       };
81911     } catch (...) {
81912       {
81913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81914       };
81915     }
81916   }
81917   jresult = (void *)result;
81918   return jresult;
81919 }
81920
81921
81922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoView_Property(void * jarg1) {
81923   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81924
81925   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81926   {
81927     try {
81928       delete arg1;
81929     } catch (std::out_of_range& e) {
81930       {
81931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81932       };
81933     } catch (std::exception& e) {
81934       {
81935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81936       };
81937     } catch (...) {
81938       {
81939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81940       };
81941     }
81942   }
81943 }
81944
81945
81946 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_New__SWIG_0() {
81947   void * jresult ;
81948   Dali::Toolkit::VideoView result;
81949
81950   {
81951     try {
81952       result = Dali::Toolkit::VideoView::New();
81953     } catch (std::out_of_range& e) {
81954       {
81955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (std::exception& e) {
81958       {
81959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81964       };
81965     }
81966   }
81967   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81968   return jresult;
81969 }
81970
81971
81972 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_New__SWIG_1(char * jarg1) {
81973   void * jresult ;
81974   std::string *arg1 = 0 ;
81975   Dali::Toolkit::VideoView result;
81976
81977   if (!jarg1) {
81978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81979     return 0;
81980   }
81981   std::string arg1_str(jarg1);
81982   arg1 = &arg1_str;
81983   {
81984     try {
81985       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81986     } catch (std::out_of_range& e) {
81987       {
81988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81989       };
81990     } catch (std::exception& e) {
81991       {
81992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81997       };
81998     }
81999   }
82000   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82001
82002   //argout typemap for const std::string&
82003
82004   return jresult;
82005 }
82006
82007
82008 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView__SWIG_0() {
82009   void * jresult ;
82010   Dali::Toolkit::VideoView *result = 0 ;
82011
82012   {
82013     try {
82014       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82015     } catch (std::out_of_range& e) {
82016       {
82017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82018       };
82019     } catch (std::exception& e) {
82020       {
82021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82022       };
82023     } catch (...) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82026       };
82027     }
82028   }
82029   jresult = (void *)result;
82030   return jresult;
82031 }
82032
82033
82034 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoView(void * jarg1) {
82035   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82036
82037   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82038   {
82039     try {
82040       delete arg1;
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82052       };
82053     }
82054   }
82055 }
82056
82057
82058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView__SWIG_1(void * jarg1) {
82059   void * jresult ;
82060   Dali::Toolkit::VideoView *arg1 = 0 ;
82061   Dali::Toolkit::VideoView *result = 0 ;
82062
82063   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82064   if (!arg1) {
82065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82066     return 0;
82067   }
82068   {
82069     try {
82070       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82071     } catch (std::out_of_range& e) {
82072       {
82073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82074       };
82075     } catch (std::exception& e) {
82076       {
82077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82078       };
82079     } catch (...) {
82080       {
82081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82082       };
82083     }
82084   }
82085   jresult = (void *)result;
82086   return jresult;
82087 }
82088
82089
82090 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_Assign(void * jarg1, void * jarg2) {
82091   void * jresult ;
82092   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82093   Dali::Toolkit::VideoView *arg2 = 0 ;
82094   Dali::Toolkit::VideoView *result = 0 ;
82095
82096   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82097   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82098   if (!arg2) {
82099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82100     return 0;
82101   }
82102   {
82103     try {
82104       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82105     } catch (std::out_of_range& e) {
82106       {
82107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82108       };
82109     } catch (std::exception& e) {
82110       {
82111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82112       };
82113     } catch (...) {
82114       {
82115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82116       };
82117     }
82118   }
82119   jresult = (void *)result;
82120   return jresult;
82121 }
82122
82123
82124 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_DownCast(void * jarg1) {
82125   void * jresult ;
82126   Dali::BaseHandle arg1 ;
82127   Dali::BaseHandle *argp1 ;
82128   Dali::Toolkit::VideoView result;
82129
82130   argp1 = (Dali::BaseHandle *)jarg1;
82131   if (!argp1) {
82132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82133     return 0;
82134   }
82135   arg1 = *argp1;
82136   {
82137     try {
82138       result = Dali::Toolkit::VideoView::DownCast(arg1);
82139     } catch (std::out_of_range& e) {
82140       {
82141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82142       };
82143     } catch (std::exception& e) {
82144       {
82145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82146       };
82147     } catch (...) {
82148       {
82149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82150       };
82151     }
82152   }
82153   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82154   return jresult;
82155 }
82156
82157
82158 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Play(void * jarg1) {
82159   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82160
82161   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82162   {
82163     try {
82164       (arg1)->Play();
82165     } catch (std::out_of_range& e) {
82166       {
82167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82168       };
82169     } catch (std::exception& e) {
82170       {
82171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82172       };
82173     } catch (...) {
82174       {
82175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82176       };
82177     }
82178   }
82179 }
82180
82181
82182 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Pause(void * jarg1) {
82183   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82184
82185   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82186   {
82187     try {
82188       (arg1)->Pause();
82189     } catch (std::out_of_range& e) {
82190       {
82191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82192       };
82193     } catch (std::exception& e) {
82194       {
82195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82196       };
82197     } catch (...) {
82198       {
82199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82200       };
82201     }
82202   }
82203 }
82204
82205
82206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Stop(void * jarg1) {
82207   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82208
82209   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82210   {
82211     try {
82212       (arg1)->Stop();
82213     } catch (std::out_of_range& e) {
82214       {
82215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82216       };
82217     } catch (std::exception& e) {
82218       {
82219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82220       };
82221     } catch (...) {
82222       {
82223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82224       };
82225     }
82226   }
82227 }
82228
82229
82230 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Forward(void * jarg1, int jarg2) {
82231   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82232   int arg2 ;
82233
82234   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82235   arg2 = (int)jarg2;
82236   {
82237     try {
82238       (arg1)->Forward(arg2);
82239     } catch (std::out_of_range& e) {
82240       {
82241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82242       };
82243     } catch (std::exception& e) {
82244       {
82245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82246       };
82247     } catch (...) {
82248       {
82249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82250       };
82251     }
82252   }
82253 }
82254
82255
82256 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Backward(void * jarg1, int jarg2) {
82257   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82258   int arg2 ;
82259
82260   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82261   arg2 = (int)jarg2;
82262   {
82263     try {
82264       (arg1)->Backward(arg2);
82265     } catch (std::out_of_range& e) {
82266       {
82267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82268       };
82269     } catch (std::exception& e) {
82270       {
82271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82272       };
82273     } catch (...) {
82274       {
82275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82276       };
82277     }
82278   }
82279 }
82280
82281
82282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_FinishedSignal(void * jarg1) {
82283   void * jresult ;
82284   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82285   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82286
82287   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82288   {
82289     try {
82290       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82291     } catch (std::out_of_range& e) {
82292       {
82293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82294       };
82295     } catch (std::exception& e) {
82296       {
82297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82298       };
82299     } catch (...) {
82300       {
82301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82302       };
82303     }
82304   }
82305   jresult = (void *)result;
82306   return jresult;
82307 }
82308
82309
82310 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TITLE_get() {
82311   int jresult ;
82312   int result;
82313
82314   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82315   jresult = (int)result;
82316   return jresult;
82317 }
82318
82319
82320 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_CONTENT_get() {
82321   int jresult ;
82322   int result;
82323
82324   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82325   jresult = (int)result;
82326   return jresult;
82327 }
82328
82329
82330 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_FOOTER_get() {
82331   int jresult ;
82332   int result;
82333
82334   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82335   jresult = (int)result;
82336   return jresult;
82337 }
82338
82339
82340 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_DISPLAY_STATE_get() {
82341   int jresult ;
82342   int result;
82343
82344   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82345   jresult = (int)result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TOUCH_TRANSPARENT_get() {
82351   int jresult ;
82352   int result;
82353
82354   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82355   jresult = (int)result;
82356   return jresult;
82357 }
82358
82359
82360 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_VISIBILITY_get() {
82361   int jresult ;
82362   int result;
82363
82364   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82365   jresult = (int)result;
82366   return jresult;
82367 }
82368
82369
82370 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_POSITION_get() {
82371   int jresult ;
82372   int result;
82373
82374   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82375   jresult = (int)result;
82376   return jresult;
82377 }
82378
82379
82380 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_CONTEXTUAL_MODE_get() {
82381   int jresult ;
82382   int result;
82383
82384   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82385   jresult = (int)result;
82386   return jresult;
82387 }
82388
82389
82390 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ANIMATION_DURATION_get() {
82391   int jresult ;
82392   int result;
82393
82394   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82395   jresult = (int)result;
82396   return jresult;
82397 }
82398
82399
82400 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ANIMATION_MODE_get() {
82401   int jresult ;
82402   int result;
82403
82404   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82405   jresult = (int)result;
82406   return jresult;
82407 }
82408
82409
82410 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ENTRY_ANIMATION_get() {
82411   int jresult ;
82412   int result;
82413
82414   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82415   jresult = (int)result;
82416   return jresult;
82417 }
82418
82419
82420 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_EXIT_ANIMATION_get() {
82421   int jresult ;
82422   int result;
82423
82424   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82425   jresult = (int)result;
82426   return jresult;
82427 }
82428
82429
82430 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_AUTO_HIDE_DELAY_get() {
82431   int jresult ;
82432   int result;
82433
82434   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82435   jresult = (int)result;
82436   return jresult;
82437 }
82438
82439
82440 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_BACKING_ENABLED_get() {
82441   int jresult ;
82442   int result;
82443
82444   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82445   jresult = (int)result;
82446   return jresult;
82447 }
82448
82449
82450 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_BACKING_COLOR_get() {
82451   int jresult ;
82452   int result;
82453
82454   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82455   jresult = (int)result;
82456   return jresult;
82457 }
82458
82459
82460 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82461   int jresult ;
82462   int result;
82463
82464   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82465   jresult = (int)result;
82466   return jresult;
82467 }
82468
82469 /* this should be fixed after tizen branch being upgraded!
82470 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82471   int jresult ;
82472   int result;
82473
82474   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82475   jresult = (int)result;
82476   return jresult;
82477 }
82478 */
82479
82480 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_UP_IMAGE_get() {
82481   int jresult ;
82482   int result;
82483
82484   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82485   jresult = (int)result;
82486   return jresult;
82487 }
82488
82489
82490 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_DOWN_IMAGE_get() {
82491   int jresult ;
82492   int result;
82493
82494   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82495   jresult = (int)result;
82496   return jresult;
82497 }
82498
82499
82500 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_LEFT_IMAGE_get() {
82501   int jresult ;
82502   int result;
82503
82504   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82505   jresult = (int)result;
82506   return jresult;
82507 }
82508
82509
82510 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82511   int jresult ;
82512   int result;
82513
82514   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82515   jresult = (int)result;
82516   return jresult;
82517 }
82518
82519
82520 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup_Property() {
82521   void * jresult ;
82522   Dali::Toolkit::Popup::Property *result = 0 ;
82523
82524   {
82525     try {
82526       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82527     } catch (std::out_of_range& e) {
82528       {
82529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82530       };
82531     } catch (std::exception& e) {
82532       {
82533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82534       };
82535     } catch (...) {
82536       {
82537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82538       };
82539     }
82540   }
82541   jresult = (void *)result;
82542   return jresult;
82543 }
82544
82545
82546 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Popup_Property(void * jarg1) {
82547   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82548
82549   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82550   {
82551     try {
82552       delete arg1;
82553     } catch (std::out_of_range& e) {
82554       {
82555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82556       };
82557     } catch (std::exception& e) {
82558       {
82559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82560       };
82561     } catch (...) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82564       };
82565     }
82566   }
82567 }
82568
82569
82570 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup__SWIG_0() {
82571   void * jresult ;
82572   Dali::Toolkit::Popup *result = 0 ;
82573
82574   {
82575     try {
82576       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82577     } catch (std::out_of_range& e) {
82578       {
82579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82580       };
82581     } catch (std::exception& e) {
82582       {
82583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (...) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82588       };
82589     }
82590   }
82591   jresult = (void *)result;
82592   return jresult;
82593 }
82594
82595
82596 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_New() {
82597   void * jresult ;
82598   Dali::Toolkit::Popup result;
82599
82600   {
82601     try {
82602       result = Dali::Toolkit::Popup::New();
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82614       };
82615     }
82616   }
82617   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Popup(void * jarg1) {
82623   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82624
82625   arg1 = (Dali::Toolkit::Popup *)jarg1;
82626   {
82627     try {
82628       delete arg1;
82629     } catch (std::out_of_range& e) {
82630       {
82631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82632       };
82633     } catch (std::exception& e) {
82634       {
82635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82636       };
82637     } catch (...) {
82638       {
82639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82640       };
82641     }
82642   }
82643 }
82644
82645
82646 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup__SWIG_1(void * jarg1) {
82647   void * jresult ;
82648   Dali::Toolkit::Popup *arg1 = 0 ;
82649   Dali::Toolkit::Popup *result = 0 ;
82650
82651   arg1 = (Dali::Toolkit::Popup *)jarg1;
82652   if (!arg1) {
82653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82654     return 0;
82655   }
82656   {
82657     try {
82658       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82659     } catch (std::out_of_range& e) {
82660       {
82661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (std::exception& e) {
82664       {
82665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82666       };
82667     } catch (...) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82670       };
82671     }
82672   }
82673   jresult = (void *)result;
82674   return jresult;
82675 }
82676
82677
82678 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_Assign(void * jarg1, void * jarg2) {
82679   void * jresult ;
82680   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82681   Dali::Toolkit::Popup *arg2 = 0 ;
82682   Dali::Toolkit::Popup *result = 0 ;
82683
82684   arg1 = (Dali::Toolkit::Popup *)jarg1;
82685   arg2 = (Dali::Toolkit::Popup *)jarg2;
82686   if (!arg2) {
82687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82688     return 0;
82689   }
82690   {
82691     try {
82692       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82693     } catch (std::out_of_range& e) {
82694       {
82695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82696       };
82697     } catch (std::exception& e) {
82698       {
82699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (...) {
82702       {
82703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82704       };
82705     }
82706   }
82707   jresult = (void *)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_DownCast(void * jarg1) {
82713   void * jresult ;
82714   Dali::BaseHandle arg1 ;
82715   Dali::BaseHandle *argp1 ;
82716   Dali::Toolkit::Popup result;
82717
82718   argp1 = (Dali::BaseHandle *)jarg1;
82719   if (!argp1) {
82720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82721     return 0;
82722   }
82723   arg1 = *argp1;
82724   {
82725     try {
82726       result = Dali::Toolkit::Popup::DownCast(arg1);
82727     } catch (std::out_of_range& e) {
82728       {
82729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82730       };
82731     } catch (std::exception& e) {
82732       {
82733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82734       };
82735     } catch (...) {
82736       {
82737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82738       };
82739     }
82740   }
82741   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82742   return jresult;
82743 }
82744
82745
82746 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetTitle(void * jarg1, void * jarg2) {
82747   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82748   Dali::Actor arg2 ;
82749   Dali::Actor *argp2 ;
82750
82751   arg1 = (Dali::Toolkit::Popup *)jarg1;
82752   argp2 = (Dali::Actor *)jarg2;
82753   if (!argp2) {
82754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82755     return ;
82756   }
82757   arg2 = *argp2;
82758   {
82759     try {
82760       (arg1)->SetTitle(arg2);
82761     } catch (std::out_of_range& e) {
82762       {
82763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82764       };
82765     } catch (std::exception& e) {
82766       {
82767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82768       };
82769     } catch (...) {
82770       {
82771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82772       };
82773     }
82774   }
82775 }
82776
82777
82778 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetTitle(void * jarg1) {
82779   void * jresult ;
82780   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82781   Dali::Actor result;
82782
82783   arg1 = (Dali::Toolkit::Popup *)jarg1;
82784   {
82785     try {
82786       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82787     } catch (std::out_of_range& e) {
82788       {
82789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82790       };
82791     } catch (std::exception& e) {
82792       {
82793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (...) {
82796       {
82797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82798       };
82799     }
82800   }
82801   jresult = new Dali::Actor((const Dali::Actor &)result);
82802   return jresult;
82803 }
82804
82805
82806 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetContent(void * jarg1, void * jarg2) {
82807   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82808   Dali::Actor arg2 ;
82809   Dali::Actor *argp2 ;
82810
82811   arg1 = (Dali::Toolkit::Popup *)jarg1;
82812   argp2 = (Dali::Actor *)jarg2;
82813   if (!argp2) {
82814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82815     return ;
82816   }
82817   arg2 = *argp2;
82818   {
82819     try {
82820       (arg1)->SetContent(arg2);
82821     } catch (std::out_of_range& e) {
82822       {
82823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82824       };
82825     } catch (std::exception& e) {
82826       {
82827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82828       };
82829     } catch (...) {
82830       {
82831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82832       };
82833     }
82834   }
82835 }
82836
82837
82838 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetContent(void * jarg1) {
82839   void * jresult ;
82840   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82841   Dali::Actor result;
82842
82843   arg1 = (Dali::Toolkit::Popup *)jarg1;
82844   {
82845     try {
82846       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82847     } catch (std::out_of_range& e) {
82848       {
82849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82850       };
82851     } catch (std::exception& e) {
82852       {
82853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82854       };
82855     } catch (...) {
82856       {
82857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82858       };
82859     }
82860   }
82861   jresult = new Dali::Actor((const Dali::Actor &)result);
82862   return jresult;
82863 }
82864
82865
82866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetFooter(void * jarg1, void * jarg2) {
82867   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82868   Dali::Actor arg2 ;
82869   Dali::Actor *argp2 ;
82870
82871   arg1 = (Dali::Toolkit::Popup *)jarg1;
82872   argp2 = (Dali::Actor *)jarg2;
82873   if (!argp2) {
82874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82875     return ;
82876   }
82877   arg2 = *argp2;
82878   {
82879     try {
82880       (arg1)->SetFooter(arg2);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82888       };
82889     } catch (...) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82892       };
82893     }
82894   }
82895 }
82896
82897
82898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetFooter(void * jarg1) {
82899   void * jresult ;
82900   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82901   Dali::Actor result;
82902
82903   arg1 = (Dali::Toolkit::Popup *)jarg1;
82904   {
82905     try {
82906       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82907     } catch (std::out_of_range& e) {
82908       {
82909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82910       };
82911     } catch (std::exception& e) {
82912       {
82913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82914       };
82915     } catch (...) {
82916       {
82917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82918       };
82919     }
82920   }
82921   jresult = new Dali::Actor((const Dali::Actor &)result);
82922   return jresult;
82923 }
82924
82925
82926 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetDisplayState(void * jarg1, int jarg2) {
82927   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82928   Dali::Toolkit::Popup::DisplayState arg2 ;
82929
82930   arg1 = (Dali::Toolkit::Popup *)jarg1;
82931   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82932   {
82933     try {
82934       (arg1)->SetDisplayState(arg2);
82935     } catch (std::out_of_range& e) {
82936       {
82937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82938       };
82939     } catch (std::exception& e) {
82940       {
82941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82942       };
82943     } catch (...) {
82944       {
82945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82946       };
82947     }
82948   }
82949 }
82950
82951
82952 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_GetDisplayState(void * jarg1) {
82953   int jresult ;
82954   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82955   Dali::Toolkit::Popup::DisplayState result;
82956
82957   arg1 = (Dali::Toolkit::Popup *)jarg1;
82958   {
82959     try {
82960       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82961     } catch (std::out_of_range& e) {
82962       {
82963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82964       };
82965     } catch (std::exception& e) {
82966       {
82967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82968       };
82969     } catch (...) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82972       };
82973     }
82974   }
82975   jresult = (int)result;
82976   return jresult;
82977 }
82978
82979
82980 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_OutsideTouchedSignal(void * jarg1) {
82981   void * jresult ;
82982   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82983   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82984
82985   arg1 = (Dali::Toolkit::Popup *)jarg1;
82986   {
82987     try {
82988       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82989     } catch (std::out_of_range& e) {
82990       {
82991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82992       };
82993     } catch (std::exception& e) {
82994       {
82995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82996       };
82997     } catch (...) {
82998       {
82999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83000       };
83001     }
83002   }
83003   jresult = (void *)result;
83004   return jresult;
83005 }
83006
83007
83008 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_ShowingSignal(void * jarg1) {
83009   void * jresult ;
83010   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83011   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83012
83013   arg1 = (Dali::Toolkit::Popup *)jarg1;
83014   {
83015     try {
83016       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83017     } catch (std::out_of_range& e) {
83018       {
83019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83020       };
83021     } catch (std::exception& e) {
83022       {
83023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83024       };
83025     } catch (...) {
83026       {
83027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83028       };
83029     }
83030   }
83031   jresult = (void *)result;
83032   return jresult;
83033 }
83034
83035
83036 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_ShownSignal(void * jarg1) {
83037   void * jresult ;
83038   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83039   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83040
83041   arg1 = (Dali::Toolkit::Popup *)jarg1;
83042   {
83043     try {
83044       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83045     } catch (std::out_of_range& e) {
83046       {
83047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83048       };
83049     } catch (std::exception& e) {
83050       {
83051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (...) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83056       };
83057     }
83058   }
83059   jresult = (void *)result;
83060   return jresult;
83061 }
83062
83063
83064 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_HidingSignal(void * jarg1) {
83065   void * jresult ;
83066   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83067   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83068
83069   arg1 = (Dali::Toolkit::Popup *)jarg1;
83070   {
83071     try {
83072       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83073     } catch (std::out_of_range& e) {
83074       {
83075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83076       };
83077     } catch (std::exception& e) {
83078       {
83079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83080       };
83081     } catch (...) {
83082       {
83083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83084       };
83085     }
83086   }
83087   jresult = (void *)result;
83088   return jresult;
83089 }
83090
83091
83092 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_HiddenSignal(void * jarg1) {
83093   void * jresult ;
83094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83095   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83096
83097   arg1 = (Dali::Toolkit::Popup *)jarg1;
83098   {
83099     try {
83100       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83108       };
83109     } catch (...) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83112       };
83113     }
83114   }
83115   jresult = (void *)result;
83116   return jresult;
83117 }
83118
83119
83120 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_PROGRESS_VALUE_get() {
83121   int jresult ;
83122   int result;
83123
83124   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83125   jresult = (int)result;
83126   return jresult;
83127 }
83128
83129
83130 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_TRACK_VISUAL_get() {
83131   int jresult ;
83132   int result;
83133
83134   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83135   jresult = (int)result;
83136   return jresult;
83137 }
83138
83139
83140 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_PROGRESS_VISUAL_get() {
83141   int jresult ;
83142   int result;
83143
83144   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83145   jresult = (int)result;
83146   return jresult;
83147 }
83148
83149
83150 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar_Property() {
83151   void * jresult ;
83152   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83153
83154   {
83155     try {
83156       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83157     } catch (std::out_of_range& e) {
83158       {
83159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (std::exception& e) {
83162       {
83163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83168       };
83169     }
83170   }
83171   jresult = (void *)result;
83172   return jresult;
83173 }
83174
83175
83176 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ProgressBar_Property(void * jarg1) {
83177   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83178
83179   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83180   {
83181     try {
83182       delete arg1;
83183     } catch (std::out_of_range& e) {
83184       {
83185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83186       };
83187     } catch (std::exception& e) {
83188       {
83189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83190       };
83191     } catch (...) {
83192       {
83193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83194       };
83195     }
83196   }
83197 }
83198
83199
83200 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_New() {
83201   void * jresult ;
83202   Dali::Toolkit::ProgressBar result;
83203
83204   {
83205     try {
83206       result = Dali::Toolkit::ProgressBar::New();
83207     } catch (std::out_of_range& e) {
83208       {
83209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83210       };
83211     } catch (std::exception& e) {
83212       {
83213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83214       };
83215     } catch (...) {
83216       {
83217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83218       };
83219     }
83220   }
83221   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83222   return jresult;
83223 }
83224
83225
83226 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar__SWIG_0() {
83227   void * jresult ;
83228   Dali::Toolkit::ProgressBar *result = 0 ;
83229
83230   {
83231     try {
83232       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83233     } catch (std::out_of_range& e) {
83234       {
83235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (std::exception& e) {
83238       {
83239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83240       };
83241     } catch (...) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83244       };
83245     }
83246   }
83247   jresult = (void *)result;
83248   return jresult;
83249 }
83250
83251
83252 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar__SWIG_1(void * jarg1) {
83253   void * jresult ;
83254   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83255   Dali::Toolkit::ProgressBar *result = 0 ;
83256
83257   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83258   if (!arg1) {
83259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83260     return 0;
83261   }
83262   {
83263     try {
83264       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83265     } catch (std::out_of_range& e) {
83266       {
83267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83268       };
83269     } catch (std::exception& e) {
83270       {
83271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83272       };
83273     } catch (...) {
83274       {
83275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83276       };
83277     }
83278   }
83279   jresult = (void *)result;
83280   return jresult;
83281 }
83282
83283
83284 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_Assign(void * jarg1, void * jarg2) {
83285   void * jresult ;
83286   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83287   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83288   Dali::Toolkit::ProgressBar *result = 0 ;
83289
83290   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83291   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83292   if (!arg2) {
83293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83294     return 0;
83295   }
83296   {
83297     try {
83298       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83299     } catch (std::out_of_range& e) {
83300       {
83301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83302       };
83303     } catch (std::exception& e) {
83304       {
83305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (...) {
83308       {
83309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83310       };
83311     }
83312   }
83313   jresult = (void *)result;
83314   return jresult;
83315 }
83316
83317
83318 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ProgressBar(void * jarg1) {
83319   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83320
83321   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83322   {
83323     try {
83324       delete arg1;
83325     } catch (std::out_of_range& e) {
83326       {
83327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83328       };
83329     } catch (std::exception& e) {
83330       {
83331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83332       };
83333     } catch (...) {
83334       {
83335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83336       };
83337     }
83338   }
83339 }
83340
83341
83342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_DownCast(void * jarg1) {
83343   void * jresult ;
83344   Dali::BaseHandle arg1 ;
83345   Dali::BaseHandle *argp1 ;
83346   Dali::Toolkit::ProgressBar result;
83347
83348   argp1 = (Dali::BaseHandle *)jarg1;
83349   if (!argp1) {
83350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83351     return 0;
83352   }
83353   arg1 = *argp1;
83354   {
83355     try {
83356       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83357     } catch (std::out_of_range& e) {
83358       {
83359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83360       };
83361     } catch (std::exception& e) {
83362       {
83363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (...) {
83366       {
83367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83368       };
83369     }
83370   }
83371   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83372   return jresult;
83373 }
83374
83375
83376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_ValueChangedSignal(void * jarg1) {
83377   void * jresult ;
83378   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83379   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83380
83381   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83382   {
83383     try {
83384       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83385     } catch (std::out_of_range& e) {
83386       {
83387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (std::exception& e) {
83390       {
83391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83392       };
83393     } catch (...) {
83394       {
83395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83396       };
83397     }
83398   }
83399   jresult = (void *)result;
83400   return jresult;
83401 }
83402
83403
83404 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurView__SWIG_0() {
83405   void * jresult ;
83406   Dali::Toolkit::GaussianBlurView *result = 0 ;
83407
83408   {
83409     try {
83410       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83411     } catch (std::out_of_range& e) {
83412       {
83413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83414       };
83415     } catch (std::exception& e) {
83416       {
83417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83418       };
83419     } catch (...) {
83420       {
83421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83422       };
83423     }
83424   }
83425   jresult = (void *)result;
83426   return jresult;
83427 }
83428
83429
83430 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurView__SWIG_1(void * jarg1) {
83431   void * jresult ;
83432   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83433   Dali::Toolkit::GaussianBlurView *result = 0 ;
83434
83435   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83436   if (!arg1) {
83437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83438     return 0;
83439   }
83440   {
83441     try {
83442       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83443     } catch (std::out_of_range& e) {
83444       {
83445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83446       };
83447     } catch (std::exception& e) {
83448       {
83449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83454       };
83455     }
83456   }
83457   jresult = (void *)result;
83458   return jresult;
83459 }
83460
83461
83462 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83463   void * jresult ;
83464   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83465   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83466   Dali::Toolkit::GaussianBlurView *result = 0 ;
83467
83468   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83469   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83470   if (!arg2) {
83471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83472     return 0;
83473   }
83474   {
83475     try {
83476       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83477     } catch (std::out_of_range& e) {
83478       {
83479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83480       };
83481     } catch (std::exception& e) {
83482       {
83483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83484       };
83485     } catch (...) {
83486       {
83487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83488       };
83489     }
83490   }
83491   jresult = (void *)result;
83492   return jresult;
83493 }
83494
83495
83496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GaussianBlurView(void * jarg1) {
83497   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83498
83499   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83500   {
83501     try {
83502       delete arg1;
83503     } catch (std::out_of_range& e) {
83504       {
83505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83506       };
83507     } catch (std::exception& e) {
83508       {
83509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83510       };
83511     } catch (...) {
83512       {
83513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83514       };
83515     }
83516   }
83517 }
83518
83519
83520 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_DownCast(void * jarg1) {
83521   void * jresult ;
83522   Dali::BaseHandle arg1 ;
83523   Dali::BaseHandle *argp1 ;
83524   Dali::Toolkit::GaussianBlurView result;
83525
83526   argp1 = (Dali::BaseHandle *)jarg1;
83527   if (!argp1) {
83528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83529     return 0;
83530   }
83531   arg1 = *argp1;
83532   {
83533     try {
83534       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83535     } catch (std::out_of_range& e) {
83536       {
83537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83538       };
83539     } catch (std::exception& e) {
83540       {
83541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83542       };
83543     } catch (...) {
83544       {
83545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83546       };
83547     }
83548   }
83549   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83550   return jresult;
83551 }
83552
83553
83554 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_0() {
83555   void * jresult ;
83556   Dali::Toolkit::GaussianBlurView result;
83557
83558   {
83559     try {
83560       result = Dali::Toolkit::GaussianBlurView::New();
83561     } catch (std::out_of_range& e) {
83562       {
83563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83564       };
83565     } catch (std::exception& e) {
83566       {
83567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83568       };
83569     } catch (...) {
83570       {
83571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83572       };
83573     }
83574   }
83575   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83576   return jresult;
83577 }
83578
83579
83580 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83581   void * jresult ;
83582   unsigned int arg1 ;
83583   float arg2 ;
83584   Dali::Pixel::Format arg3 ;
83585   float arg4 ;
83586   float arg5 ;
83587   bool arg6 ;
83588   Dali::Toolkit::GaussianBlurView result;
83589
83590   arg1 = (unsigned int)jarg1;
83591   arg2 = (float)jarg2;
83592   arg3 = (Dali::Pixel::Format)jarg3;
83593   arg4 = (float)jarg4;
83594   arg5 = (float)jarg5;
83595   arg6 = jarg6 ? true : false;
83596   {
83597     try {
83598       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83599     } catch (std::out_of_range& e) {
83600       {
83601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83602       };
83603     } catch (std::exception& e) {
83604       {
83605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83606       };
83607     } catch (...) {
83608       {
83609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83610       };
83611     }
83612   }
83613   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83614   return jresult;
83615 }
83616
83617
83618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83619   void * jresult ;
83620   unsigned int arg1 ;
83621   float arg2 ;
83622   Dali::Pixel::Format arg3 ;
83623   float arg4 ;
83624   float arg5 ;
83625   Dali::Toolkit::GaussianBlurView result;
83626
83627   arg1 = (unsigned int)jarg1;
83628   arg2 = (float)jarg2;
83629   arg3 = (Dali::Pixel::Format)jarg3;
83630   arg4 = (float)jarg4;
83631   arg5 = (float)jarg5;
83632   {
83633     try {
83634       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83635     } catch (std::out_of_range& e) {
83636       {
83637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83638       };
83639     } catch (std::exception& e) {
83640       {
83641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83642       };
83643     } catch (...) {
83644       {
83645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83646       };
83647     }
83648   }
83649   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83650   return jresult;
83651 }
83652
83653
83654 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83655   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83656   Dali::Actor arg2 ;
83657   Dali::Actor *argp2 ;
83658
83659   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83660   argp2 = (Dali::Actor *)jarg2;
83661   if (!argp2) {
83662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83663     return ;
83664   }
83665   arg2 = *argp2;
83666   {
83667     try {
83668       (arg1)->Add(arg2);
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83676       };
83677     } catch (...) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83680       };
83681     }
83682   }
83683 }
83684
83685
83686 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83687   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83688   Dali::Actor arg2 ;
83689   Dali::Actor *argp2 ;
83690
83691   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83692   argp2 = (Dali::Actor *)jarg2;
83693   if (!argp2) {
83694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83695     return ;
83696   }
83697   arg2 = *argp2;
83698   {
83699     try {
83700       (arg1)->Remove(arg2);
83701     } catch (std::out_of_range& e) {
83702       {
83703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83704       };
83705     } catch (std::exception& e) {
83706       {
83707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83708       };
83709     } catch (...) {
83710       {
83711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83712       };
83713     }
83714   }
83715 }
83716
83717
83718 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Activate(void * jarg1) {
83719   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83720
83721   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83722   {
83723     try {
83724       (arg1)->Activate();
83725     } catch (std::out_of_range& e) {
83726       {
83727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83728       };
83729     } catch (std::exception& e) {
83730       {
83731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83732       };
83733     } catch (...) {
83734       {
83735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83736       };
83737     }
83738   }
83739 }
83740
83741
83742 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_ActivateOnce(void * jarg1) {
83743   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83744
83745   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83746   {
83747     try {
83748       (arg1)->ActivateOnce();
83749     } catch (std::out_of_range& e) {
83750       {
83751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83752       };
83753     } catch (std::exception& e) {
83754       {
83755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83756       };
83757     } catch (...) {
83758       {
83759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83760       };
83761     }
83762   }
83763 }
83764
83765
83766 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Deactivate(void * jarg1) {
83767   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83768
83769   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83770   {
83771     try {
83772       (arg1)->Deactivate();
83773     } catch (std::out_of_range& e) {
83774       {
83775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83776       };
83777     } catch (std::exception& e) {
83778       {
83779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83780       };
83781     } catch (...) {
83782       {
83783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83784       };
83785     }
83786   }
83787 }
83788
83789
83790 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83791   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83792   Dali::Image arg2 ;
83793   Dali::FrameBufferImage arg3 ;
83794   Dali::Image *argp2 ;
83795   Dali::FrameBufferImage *argp3 ;
83796
83797   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83798   argp2 = (Dali::Image *)jarg2;
83799   if (!argp2) {
83800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83801     return ;
83802   }
83803   arg2 = *argp2;
83804   argp3 = (Dali::FrameBufferImage *)jarg3;
83805   if (!argp3) {
83806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83807     return ;
83808   }
83809   arg3 = *argp3;
83810   {
83811     try {
83812       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83813     } catch (std::out_of_range& e) {
83814       {
83815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83816       };
83817     } catch (std::exception& e) {
83818       {
83819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83820       };
83821     } catch (...) {
83822       {
83823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83824       };
83825     }
83826   }
83827 }
83828
83829
83830 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83831   int jresult ;
83832   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83833   Dali::Property::Index result;
83834
83835   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83836   {
83837     try {
83838       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83839     } catch (std::out_of_range& e) {
83840       {
83841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83842       };
83843     } catch (std::exception& e) {
83844       {
83845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (...) {
83848       {
83849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83850       };
83851     }
83852   }
83853   jresult = result;
83854   return jresult;
83855 }
83856
83857
83858 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83859   void * jresult ;
83860   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83861   Dali::FrameBufferImage result;
83862
83863   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83864   {
83865     try {
83866       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83867     } catch (std::out_of_range& e) {
83868       {
83869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83870       };
83871     } catch (std::exception& e) {
83872       {
83873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83878       };
83879     }
83880   }
83881   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83882   return jresult;
83883 }
83884
83885
83886 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83887   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83888   Dali::Vector4 *arg2 = 0 ;
83889
83890   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83891   arg2 = (Dali::Vector4 *)jarg2;
83892   if (!arg2) {
83893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83894     return ;
83895   }
83896   {
83897     try {
83898       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83899     } catch (std::out_of_range& e) {
83900       {
83901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83902       };
83903     } catch (std::exception& e) {
83904       {
83905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83906       };
83907     } catch (...) {
83908       {
83909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83910       };
83911     }
83912   }
83913 }
83914
83915
83916 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83917   void * jresult ;
83918   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83919   Dali::Vector4 result;
83920
83921   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83922   {
83923     try {
83924       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83925     } catch (std::out_of_range& e) {
83926       {
83927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83928       };
83929     } catch (std::exception& e) {
83930       {
83931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83932       };
83933     } catch (...) {
83934       {
83935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83936       };
83937     }
83938   }
83939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83940   return jresult;
83941 }
83942
83943
83944 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_FinishedSignal(void * jarg1) {
83945   void * jresult ;
83946   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83947   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83948
83949   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83950   {
83951     try {
83952       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (...) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83964       };
83965     }
83966   }
83967   jresult = (void *)result;
83968   return jresult;
83969 }
83970
83971
83972 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageFactory(void * jarg1) {
83973   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83974
83975   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83976   {
83977     try {
83978       delete arg1;
83979     } catch (std::out_of_range& e) {
83980       {
83981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83982       };
83983     } catch (std::exception& e) {
83984       {
83985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83986       };
83987     } catch (...) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83990       };
83991     }
83992   }
83993 }
83994
83995
83996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PageFactory_GetNumberOfPages(void * jarg1) {
83997   unsigned int jresult ;
83998   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83999   unsigned int result;
84000
84001   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84002   {
84003     try {
84004       result = (unsigned int)(arg1)->GetNumberOfPages();
84005     } catch (std::out_of_range& e) {
84006       {
84007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84008       };
84009     } catch (std::exception& e) {
84010       {
84011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84012       };
84013     } catch (...) {
84014       {
84015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84016       };
84017     }
84018   }
84019   jresult = result;
84020   return jresult;
84021 }
84022
84023
84024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84025   void * jresult ;
84026   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84027   unsigned int arg2 ;
84028   Dali::Texture result;
84029
84030   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84031   arg2 = (unsigned int)jarg2;
84032   {
84033     try {
84034       result = (arg1)->NewPage(arg2);
84035     } catch (std::out_of_range& e) {
84036       {
84037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84038       };
84039     } catch (std::exception& e) {
84040       {
84041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (...) {
84044       {
84045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84046       };
84047     }
84048   }
84049   jresult = new Dali::Texture((const Dali::Texture &)result);
84050   return jresult;
84051 }
84052
84053
84054 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_PAGE_SIZE_get() {
84055   int jresult ;
84056   int result;
84057
84058   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84059   jresult = (int)result;
84060   return jresult;
84061 }
84062
84063
84064 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84065   int jresult ;
84066   int result;
84067
84068   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84069   jresult = (int)result;
84070   return jresult;
84071 }
84072
84073
84074 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_SPINE_SHADOW_get() {
84075   int jresult ;
84076   int result;
84077
84078   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84079   jresult = (int)result;
84080   return jresult;
84081 }
84082
84083
84084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView_Property() {
84085   void * jresult ;
84086   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84087
84088   {
84089     try {
84090       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84102       };
84103     }
84104   }
84105   jresult = (void *)result;
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnView_Property(void * jarg1) {
84111   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84112
84113   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84114   {
84115     try {
84116       delete arg1;
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84124       };
84125     } catch (...) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84128       };
84129     }
84130   }
84131 }
84132
84133
84134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView__SWIG_0() {
84135   void * jresult ;
84136   Dali::Toolkit::PageTurnView *result = 0 ;
84137
84138   {
84139     try {
84140       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84141     } catch (std::out_of_range& e) {
84142       {
84143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84144       };
84145     } catch (std::exception& e) {
84146       {
84147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84148       };
84149     } catch (...) {
84150       {
84151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84152       };
84153     }
84154   }
84155   jresult = (void *)result;
84156   return jresult;
84157 }
84158
84159
84160 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView__SWIG_1(void * jarg1) {
84161   void * jresult ;
84162   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84163   Dali::Toolkit::PageTurnView *result = 0 ;
84164
84165   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84166   if (!arg1) {
84167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84168     return 0;
84169   }
84170   {
84171     try {
84172       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84173     } catch (std::out_of_range& e) {
84174       {
84175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84176       };
84177     } catch (std::exception& e) {
84178       {
84179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84180       };
84181     } catch (...) {
84182       {
84183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84184       };
84185     }
84186   }
84187   jresult = (void *)result;
84188   return jresult;
84189 }
84190
84191
84192 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_Assign(void * jarg1, void * jarg2) {
84193   void * jresult ;
84194   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84195   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84196   Dali::Toolkit::PageTurnView *result = 0 ;
84197
84198   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84199   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84200   if (!arg2) {
84201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84202     return 0;
84203   }
84204   {
84205     try {
84206       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84207     } catch (std::out_of_range& e) {
84208       {
84209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84210       };
84211     } catch (std::exception& e) {
84212       {
84213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84214       };
84215     } catch (...) {
84216       {
84217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84218       };
84219     }
84220   }
84221   jresult = (void *)result;
84222   return jresult;
84223 }
84224
84225
84226 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnView(void * jarg1) {
84227   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84228
84229   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84230   {
84231     try {
84232       delete arg1;
84233     } catch (std::out_of_range& e) {
84234       {
84235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84236       };
84237     } catch (std::exception& e) {
84238       {
84239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84240       };
84241     } catch (...) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84244       };
84245     }
84246   }
84247 }
84248
84249
84250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_DownCast(void * jarg1) {
84251   void * jresult ;
84252   Dali::BaseHandle arg1 ;
84253   Dali::BaseHandle *argp1 ;
84254   Dali::Toolkit::PageTurnView result;
84255
84256   argp1 = (Dali::BaseHandle *)jarg1;
84257   if (!argp1) {
84258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84259     return 0;
84260   }
84261   arg1 = *argp1;
84262   {
84263     try {
84264       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84265     } catch (std::out_of_range& e) {
84266       {
84267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84268       };
84269     } catch (std::exception& e) {
84270       {
84271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84272       };
84273     } catch (...) {
84274       {
84275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84276       };
84277     }
84278   }
84279   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84280   return jresult;
84281 }
84282
84283
84284 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84285   void * jresult ;
84286   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84287   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84288
84289   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84290   {
84291     try {
84292       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84293     } catch (std::out_of_range& e) {
84294       {
84295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (std::exception& e) {
84298       {
84299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84300       };
84301     } catch (...) {
84302       {
84303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84304       };
84305     }
84306   }
84307   jresult = (void *)result;
84308   return jresult;
84309 }
84310
84311
84312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84313   void * jresult ;
84314   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84315   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84316
84317   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84318   {
84319     try {
84320       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84321     } catch (std::out_of_range& e) {
84322       {
84323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84324       };
84325     } catch (std::exception& e) {
84326       {
84327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84328       };
84329     } catch (...) {
84330       {
84331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84332       };
84333     }
84334   }
84335   jresult = (void *)result;
84336   return jresult;
84337 }
84338
84339
84340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PagePanStartedSignal(void * jarg1) {
84341   void * jresult ;
84342   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84343   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84344
84345   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84346   {
84347     try {
84348       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84360       };
84361     }
84362   }
84363   jresult = (void *)result;
84364   return jresult;
84365 }
84366
84367
84368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84369   void * jresult ;
84370   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84371   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84372
84373   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84374   {
84375     try {
84376       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84377     } catch (std::out_of_range& e) {
84378       {
84379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84380       };
84381     } catch (std::exception& e) {
84382       {
84383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84384       };
84385     } catch (...) {
84386       {
84387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84388       };
84389     }
84390   }
84391   jresult = (void *)result;
84392   return jresult;
84393 }
84394
84395
84396 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnLandscapeView__SWIG_0() {
84397   void * jresult ;
84398   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84399
84400   {
84401     try {
84402       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84403     } catch (std::out_of_range& e) {
84404       {
84405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84406       };
84407     } catch (std::exception& e) {
84408       {
84409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84410       };
84411     } catch (...) {
84412       {
84413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84414       };
84415     }
84416   }
84417   jresult = (void *)result;
84418   return jresult;
84419 }
84420
84421
84422 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84423   void * jresult ;
84424   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84425   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84426
84427   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84428   if (!arg1) {
84429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84430     return 0;
84431   }
84432   {
84433     try {
84434       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84446       };
84447     }
84448   }
84449   jresult = (void *)result;
84450   return jresult;
84451 }
84452
84453
84454 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84455   void * jresult ;
84456   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84457   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84458   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84459
84460   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84461   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84462   if (!arg2) {
84463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84464     return 0;
84465   }
84466   {
84467     try {
84468       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84469     } catch (std::out_of_range& e) {
84470       {
84471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (std::exception& e) {
84474       {
84475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (...) {
84478       {
84479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84480       };
84481     }
84482   }
84483   jresult = (void *)result;
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnLandscapeView(void * jarg1) {
84489   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84490
84491   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84492   {
84493     try {
84494       delete arg1;
84495     } catch (std::out_of_range& e) {
84496       {
84497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84498       };
84499     } catch (std::exception& e) {
84500       {
84501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84502       };
84503     } catch (...) {
84504       {
84505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84506       };
84507     }
84508   }
84509 }
84510
84511
84512 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84513   void * jresult ;
84514   Dali::Toolkit::PageFactory *arg1 = 0 ;
84515   Dali::Vector2 *arg2 = 0 ;
84516   Dali::Toolkit::PageTurnLandscapeView result;
84517
84518   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84519   if (!arg1) {
84520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84521     return 0;
84522   }
84523   arg2 = (Dali::Vector2 *)jarg2;
84524   if (!arg2) {
84525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84526     return 0;
84527   }
84528   {
84529     try {
84530       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84531     } catch (std::out_of_range& e) {
84532       {
84533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84534       };
84535     } catch (std::exception& e) {
84536       {
84537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84538       };
84539     } catch (...) {
84540       {
84541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84542       };
84543     }
84544   }
84545   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_DownCast(void * jarg1) {
84551   void * jresult ;
84552   Dali::BaseHandle arg1 ;
84553   Dali::BaseHandle *argp1 ;
84554   Dali::Toolkit::PageTurnLandscapeView result;
84555
84556   argp1 = (Dali::BaseHandle *)jarg1;
84557   if (!argp1) {
84558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84559     return 0;
84560   }
84561   arg1 = *argp1;
84562   {
84563     try {
84564       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84565     } catch (std::out_of_range& e) {
84566       {
84567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84568       };
84569     } catch (std::exception& e) {
84570       {
84571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (...) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84576       };
84577     }
84578   }
84579   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84580   return jresult;
84581 }
84582
84583
84584 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnPortraitView__SWIG_0() {
84585   void * jresult ;
84586   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84587
84588   {
84589     try {
84590       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84591     } catch (std::out_of_range& e) {
84592       {
84593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (std::exception& e) {
84596       {
84597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84598       };
84599     } catch (...) {
84600       {
84601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84602       };
84603     }
84604   }
84605   jresult = (void *)result;
84606   return jresult;
84607 }
84608
84609
84610 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84611   void * jresult ;
84612   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84613   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84614
84615   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84616   if (!arg1) {
84617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84618     return 0;
84619   }
84620   {
84621     try {
84622       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84623     } catch (std::out_of_range& e) {
84624       {
84625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84626       };
84627     } catch (std::exception& e) {
84628       {
84629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (...) {
84632       {
84633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84634       };
84635     }
84636   }
84637   jresult = (void *)result;
84638   return jresult;
84639 }
84640
84641
84642 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84643   void * jresult ;
84644   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84645   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84646   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84647
84648   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84649   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84650   if (!arg2) {
84651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84652     return 0;
84653   }
84654   {
84655     try {
84656       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84657     } catch (std::out_of_range& e) {
84658       {
84659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84660       };
84661     } catch (std::exception& e) {
84662       {
84663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84664       };
84665     } catch (...) {
84666       {
84667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84668       };
84669     }
84670   }
84671   jresult = (void *)result;
84672   return jresult;
84673 }
84674
84675
84676 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnPortraitView(void * jarg1) {
84677   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84678
84679   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84680   {
84681     try {
84682       delete arg1;
84683     } catch (std::out_of_range& e) {
84684       {
84685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84686       };
84687     } catch (std::exception& e) {
84688       {
84689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84690       };
84691     } catch (...) {
84692       {
84693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84694       };
84695     }
84696   }
84697 }
84698
84699
84700 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84701   void * jresult ;
84702   Dali::Toolkit::PageFactory *arg1 = 0 ;
84703   Dali::Vector2 *arg2 = 0 ;
84704   Dali::Toolkit::PageTurnPortraitView result;
84705
84706   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84707   if (!arg1) {
84708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84709     return 0;
84710   }
84711   arg2 = (Dali::Vector2 *)jarg2;
84712   if (!arg2) {
84713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84714     return 0;
84715   }
84716   {
84717     try {
84718       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84719     } catch (std::out_of_range& e) {
84720       {
84721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84722       };
84723     } catch (std::exception& e) {
84724       {
84725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84726       };
84727     } catch (...) {
84728       {
84729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84730       };
84731     }
84732   }
84733   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84734   return jresult;
84735 }
84736
84737
84738 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_DownCast(void * jarg1) {
84739   void * jresult ;
84740   Dali::BaseHandle arg1 ;
84741   Dali::BaseHandle *argp1 ;
84742   Dali::Toolkit::PageTurnPortraitView result;
84743
84744   argp1 = (Dali::BaseHandle *)jarg1;
84745   if (!argp1) {
84746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84747     return 0;
84748   }
84749   arg1 = *argp1;
84750   {
84751     try {
84752       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84753     } catch (std::out_of_range& e) {
84754       {
84755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84756       };
84757     } catch (std::exception& e) {
84758       {
84759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84764       };
84765     }
84766   }
84767   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84768   return jresult;
84769 }
84770
84771
84772 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_0() {
84773   void * jresult ;
84774   Dali::Toolkit::Visual::Base *result = 0 ;
84775
84776   {
84777     try {
84778       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84779     } catch (std::out_of_range& e) {
84780       {
84781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84782       };
84783     } catch (std::exception& e) {
84784       {
84785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84786       };
84787     } catch (...) {
84788       {
84789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84790       };
84791     }
84792   }
84793   jresult = (void *)result;
84794   return jresult;
84795 }
84796
84797
84798 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VisualBase(void * jarg1) {
84799   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84800
84801   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84802   {
84803     try {
84804       delete arg1;
84805     } catch (std::out_of_range& e) {
84806       {
84807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84808       };
84809     } catch (std::exception& e) {
84810       {
84811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84812       };
84813     } catch (...) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84816       };
84817     }
84818   }
84819 }
84820
84821
84822 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_1(void * jarg1) {
84823   void * jresult ;
84824   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84825   Dali::Toolkit::Visual::Base *result = 0 ;
84826
84827   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84828   if (!arg1) {
84829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84830     return 0;
84831   }
84832   {
84833     try {
84834       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84835     } catch (std::out_of_range& e) {
84836       {
84837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84838       };
84839     } catch (std::exception& e) {
84840       {
84841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84842       };
84843     } catch (...) {
84844       {
84845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84846       };
84847     }
84848   }
84849   jresult = (void *)result;
84850   return jresult;
84851 }
84852
84853
84854 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualBase_Assign(void * jarg1, void * jarg2) {
84855   void * jresult ;
84856   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84857   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84858   Dali::Toolkit::Visual::Base *result = 0 ;
84859
84860   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84861   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84862   if (!arg2) {
84863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84864     return 0;
84865   }
84866   {
84867     try {
84868       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84869     } catch (std::out_of_range& e) {
84870       {
84871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84872       };
84873     } catch (std::exception& e) {
84874       {
84875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84876       };
84877     } catch (...) {
84878       {
84879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84880       };
84881     }
84882   }
84883   jresult = (void *)result;
84884   return jresult;
84885 }
84886
84887
84888 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetName(void * jarg1, char * jarg2) {
84889   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84890   std::string *arg2 = 0 ;
84891
84892   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84893   if (!jarg2) {
84894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84895     return ;
84896   }
84897   std::string arg2_str(jarg2);
84898   arg2 = &arg2_str;
84899   {
84900     try {
84901       (arg1)->SetName((std::string const &)*arg2);
84902     } catch (std::out_of_range& e) {
84903       {
84904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84905       };
84906     } catch (std::exception& e) {
84907       {
84908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84909       };
84910     } catch (...) {
84911       {
84912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84913       };
84914     }
84915   }
84916
84917   //argout typemap for const std::string&
84918
84919 }
84920
84921
84922 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_VisualBase_GetName(void * jarg1) {
84923   char * jresult ;
84924   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84925   std::string *result = 0 ;
84926
84927   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84928   {
84929     try {
84930       result = (std::string *) &(arg1)->GetName();
84931     } catch (std::out_of_range& e) {
84932       {
84933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84934       };
84935     } catch (std::exception& e) {
84936       {
84937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84938       };
84939     } catch (...) {
84940       {
84941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84942       };
84943     }
84944   }
84945   jresult = SWIG_csharp_string_callback(result->c_str());
84946   return jresult;
84947 }
84948
84949 /* this should be fixed after tizen branch being upgraded!
84950 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84951   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84952   Dali::Property::Map *arg2 = 0 ;
84953   Dali::Size arg3 ;
84954   Dali::Size *argp3 ;
84955
84956   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84957   arg2 = (Dali::Property::Map *)jarg2;
84958   if (!arg2) {
84959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84960     return ;
84961   }
84962   argp3 = (Dali::Size *)jarg3;
84963   if (!argp3) {
84964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84965     return ;
84966   }
84967   arg3 = *argp3;
84968   {
84969     try {
84970       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84971     } catch (std::out_of_range& e) {
84972       {
84973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84974       };
84975     } catch (std::exception& e) {
84976       {
84977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84978       };
84979     } catch (...) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84982       };
84983     }
84984   }
84985 }
84986 */
84987
84988 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84989   float jresult ;
84990   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84991   float arg2 ;
84992   float result;
84993
84994   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84995   arg2 = (float)jarg2;
84996   {
84997     try {
84998       result = (float)(arg1)->GetHeightForWidth(arg2);
84999     } catch (std::out_of_range& e) {
85000       {
85001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85002       };
85003     } catch (std::exception& e) {
85004       {
85005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85006       };
85007     } catch (...) {
85008       {
85009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85010       };
85011     }
85012   }
85013   jresult = result;
85014   return jresult;
85015 }
85016
85017 /* this should be fixed after tizen branch being upgraded!
85018 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85019   float jresult ;
85020   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85021   float arg2 ;
85022   float result;
85023
85024   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85025   arg2 = (float)jarg2;
85026   {
85027     try {
85028       result = (float)(arg1)->GetWidthForHeight(arg2);
85029     } catch (std::out_of_range& e) {
85030       {
85031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85032       };
85033     } catch (std::exception& e) {
85034       {
85035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85036       };
85037     } catch (...) {
85038       {
85039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85040       };
85041     }
85042   }
85043   jresult = result;
85044   return jresult;
85045 }
85046 */
85047
85048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85049   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85050   Dali::Vector2 *arg2 = 0 ;
85051
85052   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85053   arg2 = (Dali::Vector2 *)jarg2;
85054   if (!arg2) {
85055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85056     return ;
85057   }
85058   {
85059     try {
85060       (arg1)->GetNaturalSize(*arg2);
85061     } catch (std::out_of_range& e) {
85062       {
85063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85064       };
85065     } catch (std::exception& e) {
85066       {
85067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85072       };
85073     }
85074   }
85075 }
85076
85077
85078 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85079   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85080   float arg2 ;
85081
85082   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85083   arg2 = (float)jarg2;
85084   {
85085     try {
85086       (arg1)->SetDepthIndex(arg2);
85087     } catch (std::out_of_range& e) {
85088       {
85089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85090       };
85091     } catch (std::exception& e) {
85092       {
85093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85094       };
85095     } catch (...) {
85096       {
85097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85098       };
85099     }
85100   }
85101 }
85102
85103
85104 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetDepthIndex(void * jarg1) {
85105   float jresult ;
85106   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85107   float result;
85108
85109   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85110   {
85111     try {
85112       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85113     } catch (std::out_of_range& e) {
85114       {
85115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85116       };
85117     } catch (std::exception& e) {
85118       {
85119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85120       };
85121     } catch (...) {
85122       {
85123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85124       };
85125     }
85126   }
85127   jresult = result;
85128   return jresult;
85129 }
85130
85131
85132 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85133   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85134   Dali::Property::Map *arg2 = 0 ;
85135
85136   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85137   arg2 = (Dali::Property::Map *)jarg2;
85138   if (!arg2) {
85139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85140     return ;
85141   }
85142   {
85143     try {
85144       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85145     } catch (std::out_of_range& e) {
85146       {
85147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85148       };
85149     } catch (std::exception& e) {
85150       {
85151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85152       };
85153     } catch (...) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85156       };
85157     }
85158   }
85159 }
85160
85161
85162 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_2(void * jarg1) {
85163   void * jresult ;
85164   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85165   Dali::Toolkit::Visual::Base *result = 0 ;
85166
85167   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85168   {
85169     try {
85170       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85171     } catch (std::out_of_range& e) {
85172       {
85173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85174       };
85175     } catch (std::exception& e) {
85176       {
85177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (...) {
85180       {
85181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85182       };
85183     }
85184   }
85185   jresult = (void *)result;
85186   return jresult;
85187 }
85188
85189
85190 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_Get() {
85191   void * jresult ;
85192   Dali::Toolkit::VisualFactory result;
85193
85194   {
85195     try {
85196       result = Dali::Toolkit::VisualFactory::Get();
85197     } catch (std::out_of_range& e) {
85198       {
85199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85200       };
85201     } catch (std::exception& e) {
85202       {
85203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (...) {
85206       {
85207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85208       };
85209     }
85210   }
85211   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85212   return jresult;
85213 }
85214
85215
85216 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualFactory__SWIG_0() {
85217   void * jresult ;
85218   Dali::Toolkit::VisualFactory *result = 0 ;
85219
85220   {
85221     try {
85222       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85223     } catch (std::out_of_range& e) {
85224       {
85225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85226       };
85227     } catch (std::exception& e) {
85228       {
85229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85230       };
85231     } catch (...) {
85232       {
85233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85234       };
85235     }
85236   }
85237   jresult = (void *)result;
85238   return jresult;
85239 }
85240
85241
85242 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VisualFactory(void * jarg1) {
85243   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85244
85245   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85246   {
85247     try {
85248       delete arg1;
85249     } catch (std::out_of_range& e) {
85250       {
85251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85252       };
85253     } catch (std::exception& e) {
85254       {
85255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85256       };
85257     } catch (...) {
85258       {
85259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85260       };
85261     }
85262   }
85263 }
85264
85265
85266 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualFactory__SWIG_1(void * jarg1) {
85267   void * jresult ;
85268   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85269   Dali::Toolkit::VisualFactory *result = 0 ;
85270
85271   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85272   if (!arg1) {
85273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85274     return 0;
85275   }
85276   {
85277     try {
85278       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85279     } catch (std::out_of_range& e) {
85280       {
85281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85282       };
85283     } catch (std::exception& e) {
85284       {
85285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85286       };
85287     } catch (...) {
85288       {
85289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85290       };
85291     }
85292   }
85293   jresult = (void *)result;
85294   return jresult;
85295 }
85296
85297
85298 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_Assign(void * jarg1, void * jarg2) {
85299   void * jresult ;
85300   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85301   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85302   Dali::Toolkit::VisualFactory *result = 0 ;
85303
85304   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85305   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85306   if (!arg2) {
85307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85308     return 0;
85309   }
85310   {
85311     try {
85312       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85313     } catch (std::out_of_range& e) {
85314       {
85315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85316       };
85317     } catch (std::exception& e) {
85318       {
85319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85320       };
85321     } catch (...) {
85322       {
85323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85324       };
85325     }
85326   }
85327   jresult = (void *)result;
85328   return jresult;
85329 }
85330
85331
85332 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85333   void * jresult ;
85334   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85335   Dali::Property::Map *arg2 = 0 ;
85336   Dali::Toolkit::Visual::Base result;
85337
85338   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85339   arg2 = (Dali::Property::Map *)jarg2;
85340   if (!arg2) {
85341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85342     return 0;
85343   }
85344   {
85345     try {
85346       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85347     } catch (std::out_of_range& e) {
85348       {
85349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85350       };
85351     } catch (std::exception& e) {
85352       {
85353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85354       };
85355     } catch (...) {
85356       {
85357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85358       };
85359     }
85360   }
85361   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85362   return jresult;
85363 }
85364
85365
85366 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85367   void * jresult ;
85368   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85369   Dali::Image *arg2 = 0 ;
85370   Dali::Toolkit::Visual::Base result;
85371
85372   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85373   arg2 = (Dali::Image *)jarg2;
85374   if (!arg2) {
85375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85376     return 0;
85377   }
85378   {
85379     try {
85380       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85381     } catch (std::out_of_range& e) {
85382       {
85383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (std::exception& e) {
85386       {
85387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85392       };
85393     }
85394   }
85395   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85396   return jresult;
85397 }
85398
85399
85400 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85401   void * jresult ;
85402   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85403   std::string *arg2 = 0 ;
85404   Dali::ImageDimensions arg3 ;
85405   Dali::ImageDimensions *argp3 ;
85406   Dali::Toolkit::Visual::Base result;
85407
85408   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85409   if (!jarg2) {
85410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85411     return 0;
85412   }
85413   std::string arg2_str(jarg2);
85414   arg2 = &arg2_str;
85415   argp3 = (Dali::ImageDimensions *)jarg3;
85416   if (!argp3) {
85417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85418     return 0;
85419   }
85420   arg3 = *argp3;
85421   {
85422     try {
85423       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (...) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85435       };
85436     }
85437   }
85438   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85439
85440   //argout typemap for const std::string&
85441
85442   return jresult;
85443 }
85444
85445
85446 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_0() {
85447   void * jresult ;
85448   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85449
85450   {
85451     try {
85452       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85453     } catch (std::out_of_range& e) {
85454       {
85455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85456       };
85457     } catch (std::exception& e) {
85458       {
85459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85460       };
85461     } catch (...) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85464       };
85465     }
85466   }
85467   jresult = (void *)result;
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AsyncImageLoader(void * jarg1) {
85473   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85474
85475   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85476   {
85477     try {
85478       delete arg1;
85479     } catch (std::out_of_range& e) {
85480       {
85481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85482       };
85483     } catch (std::exception& e) {
85484       {
85485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85486       };
85487     } catch (...) {
85488       {
85489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85490       };
85491     }
85492   }
85493 }
85494
85495
85496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85497   void * jresult ;
85498   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85499   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85500
85501   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85502   if (!arg1) {
85503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85504     return 0;
85505   }
85506   {
85507     try {
85508       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85509     } catch (std::out_of_range& e) {
85510       {
85511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85512       };
85513     } catch (std::exception& e) {
85514       {
85515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85516       };
85517     } catch (...) {
85518       {
85519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85520       };
85521     }
85522   }
85523   jresult = (void *)result;
85524   return jresult;
85525 }
85526
85527
85528 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85529   void * jresult ;
85530   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85531   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85532   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85533
85534   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85535   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85536   if (!arg2) {
85537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85538     return 0;
85539   }
85540   {
85541     try {
85542       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85543     } catch (std::out_of_range& e) {
85544       {
85545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85546       };
85547     } catch (std::exception& e) {
85548       {
85549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (...) {
85552       {
85553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85554       };
85555     }
85556   }
85557   jresult = (void *)result;
85558   return jresult;
85559 }
85560
85561
85562 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_New() {
85563   void * jresult ;
85564   Dali::Toolkit::AsyncImageLoader result;
85565
85566   {
85567     try {
85568       result = Dali::Toolkit::AsyncImageLoader::New();
85569     } catch (std::out_of_range& e) {
85570       {
85571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85572       };
85573     } catch (std::exception& e) {
85574       {
85575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85576       };
85577     } catch (...) {
85578       {
85579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85580       };
85581     }
85582   }
85583   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85584   return jresult;
85585 }
85586
85587
85588 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_DownCast(void * jarg1) {
85589   void * jresult ;
85590   Dali::BaseHandle arg1 ;
85591   Dali::BaseHandle *argp1 ;
85592   Dali::Toolkit::AsyncImageLoader result;
85593
85594   argp1 = (Dali::BaseHandle *)jarg1;
85595   if (!argp1) {
85596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85597     return 0;
85598   }
85599   arg1 = *argp1;
85600   {
85601     try {
85602       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85603     } catch (std::out_of_range& e) {
85604       {
85605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85606       };
85607     } catch (std::exception& e) {
85608       {
85609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85610       };
85611     } catch (...) {
85612       {
85613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85614       };
85615     }
85616   }
85617   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85618   return jresult;
85619 }
85620
85621
85622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85623   unsigned int jresult ;
85624   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85625   std::string *arg2 = 0 ;
85626   uint32_t result;
85627
85628   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85629   if (!jarg2) {
85630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85631     return 0;
85632   }
85633   std::string arg2_str(jarg2);
85634   arg2 = &arg2_str;
85635   {
85636     try {
85637       result = (arg1)->Load((std::string const &)*arg2);
85638     } catch (std::out_of_range& e) {
85639       {
85640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85641       };
85642     } catch (std::exception& e) {
85643       {
85644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85645       };
85646     } catch (...) {
85647       {
85648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85649       };
85650     }
85651   }
85652   jresult = result;
85653
85654   //argout typemap for const std::string&
85655
85656   return jresult;
85657 }
85658
85659
85660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85661   unsigned int jresult ;
85662   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85663   std::string *arg2 = 0 ;
85664   Dali::ImageDimensions arg3 ;
85665   Dali::ImageDimensions *argp3 ;
85666   uint32_t result;
85667
85668   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85669   if (!jarg2) {
85670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85671     return 0;
85672   }
85673   std::string arg2_str(jarg2);
85674   arg2 = &arg2_str;
85675   argp3 = (Dali::ImageDimensions *)jarg3;
85676   if (!argp3) {
85677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85678     return 0;
85679   }
85680   arg3 = *argp3;
85681   {
85682     try {
85683       result = (arg1)->Load((std::string const &)*arg2,arg3);
85684     } catch (std::out_of_range& e) {
85685       {
85686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85687       };
85688     } catch (std::exception& e) {
85689       {
85690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85691       };
85692     } catch (...) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85695       };
85696     }
85697   }
85698   jresult = result;
85699
85700   //argout typemap for const std::string&
85701
85702   return jresult;
85703 }
85704
85705
85706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85707   unsigned int jresult ;
85708   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85709   std::string *arg2 = 0 ;
85710   Dali::ImageDimensions arg3 ;
85711   Dali::FittingMode::Type arg4 ;
85712   Dali::SamplingMode::Type arg5 ;
85713   bool arg6 ;
85714   Dali::ImageDimensions *argp3 ;
85715   uint32_t result;
85716
85717   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85718   if (!jarg2) {
85719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85720     return 0;
85721   }
85722   std::string arg2_str(jarg2);
85723   arg2 = &arg2_str;
85724   argp3 = (Dali::ImageDimensions *)jarg3;
85725   if (!argp3) {
85726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85727     return 0;
85728   }
85729   arg3 = *argp3;
85730   arg4 = (Dali::FittingMode::Type)jarg4;
85731   arg5 = (Dali::SamplingMode::Type)jarg5;
85732   arg6 = jarg6 ? true : false;
85733   {
85734     try {
85735       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85736     } catch (std::out_of_range& e) {
85737       {
85738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85739       };
85740     } catch (std::exception& e) {
85741       {
85742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85743       };
85744     } catch (...) {
85745       {
85746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85747       };
85748     }
85749   }
85750   jresult = result;
85751
85752   //argout typemap for const std::string&
85753
85754   return jresult;
85755 }
85756
85757
85758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85759   unsigned int jresult ;
85760   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85761   uint32_t arg2 ;
85762   bool result;
85763
85764   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85765   arg2 = (uint32_t)jarg2;
85766   {
85767     try {
85768       result = (bool)(arg1)->Cancel(arg2);
85769     } catch (std::out_of_range& e) {
85770       {
85771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85772       };
85773     } catch (std::exception& e) {
85774       {
85775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85776       };
85777     } catch (...) {
85778       {
85779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85780       };
85781     }
85782   }
85783   jresult = result;
85784   return jresult;
85785 }
85786
85787
85788 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AsyncImageLoader_CancelAll(void * jarg1) {
85789   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85790
85791   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85792   {
85793     try {
85794       (arg1)->CancelAll();
85795     } catch (std::out_of_range& e) {
85796       {
85797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85798       };
85799     } catch (std::exception& e) {
85800       {
85801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85806       };
85807     }
85808   }
85809 }
85810
85811
85812 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85813   void * jresult ;
85814   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85815   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85816
85817   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85818   {
85819     try {
85820       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85821     } catch (std::out_of_range& e) {
85822       {
85823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85824       };
85825     } catch (std::exception& e) {
85826       {
85827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85828       };
85829     } catch (...) {
85830       {
85831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85832       };
85833     }
85834   }
85835   jresult = (void *)result;
85836   return jresult;
85837 }
85838
85839
85840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85841   void * jresult ;
85842   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85843   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85844
85845   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85846   {
85847     try {
85848       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85849     } catch (std::out_of_range& e) {
85850       {
85851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85852       };
85853     } catch (std::exception& e) {
85854       {
85855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85856       };
85857     } catch (...) {
85858       {
85859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85860       };
85861     }
85862   }
85863   jresult = (void *)result;
85864   return jresult;
85865 }
85866
85867
85868 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_0(char * jarg1) {
85869   void * jresult ;
85870   std::string *arg1 = 0 ;
85871   Dali::PixelData result;
85872
85873   if (!jarg1) {
85874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85875     return 0;
85876   }
85877   std::string arg1_str(jarg1);
85878   arg1 = &arg1_str;
85879   {
85880     try {
85881       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85882     } catch (std::out_of_range& e) {
85883       {
85884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85885       };
85886     } catch (std::exception& e) {
85887       {
85888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85889       };
85890     } catch (...) {
85891       {
85892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85893       };
85894     }
85895   }
85896   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85897
85898   //argout typemap for const std::string&
85899
85900   return jresult;
85901 }
85902
85903
85904 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85905   void * jresult ;
85906   std::string *arg1 = 0 ;
85907   Dali::ImageDimensions arg2 ;
85908   Dali::ImageDimensions *argp2 ;
85909   Dali::PixelData result;
85910
85911   if (!jarg1) {
85912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85913     return 0;
85914   }
85915   std::string arg1_str(jarg1);
85916   arg1 = &arg1_str;
85917   argp2 = (Dali::ImageDimensions *)jarg2;
85918   if (!argp2) {
85919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85920     return 0;
85921   }
85922   arg2 = *argp2;
85923   {
85924     try {
85925       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85926     } catch (std::out_of_range& e) {
85927       {
85928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85929       };
85930     } catch (std::exception& e) {
85931       {
85932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85933       };
85934     } catch (...) {
85935       {
85936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85937       };
85938     }
85939   }
85940   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85941
85942   //argout typemap for const std::string&
85943
85944   return jresult;
85945 }
85946
85947
85948 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85949   void * jresult ;
85950   std::string *arg1 = 0 ;
85951   Dali::ImageDimensions arg2 ;
85952   Dali::FittingMode::Type arg3 ;
85953   Dali::SamplingMode::Type arg4 ;
85954   bool arg5 ;
85955   Dali::ImageDimensions *argp2 ;
85956   Dali::PixelData result;
85957
85958   if (!jarg1) {
85959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85960     return 0;
85961   }
85962   std::string arg1_str(jarg1);
85963   arg1 = &arg1_str;
85964   argp2 = (Dali::ImageDimensions *)jarg2;
85965   if (!argp2) {
85966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85967     return 0;
85968   }
85969   arg2 = *argp2;
85970   arg3 = (Dali::FittingMode::Type)jarg3;
85971   arg4 = (Dali::SamplingMode::Type)jarg4;
85972   arg5 = jarg5 ? true : false;
85973   {
85974     try {
85975       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85976     } catch (std::out_of_range& e) {
85977       {
85978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (std::exception& e) {
85981       {
85982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (...) {
85985       {
85986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85987       };
85988     }
85989   }
85990   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85991
85992   //argout typemap for const std::string&
85993
85994   return jresult;
85995 }
85996
85997
85998 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Clear(void * jarg1) {
85999   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86000
86001   arg1 = (std::vector< unsigned int > *)jarg1;
86002   {
86003     try {
86004       (arg1)->clear();
86005     } catch (std::out_of_range& e) {
86006       {
86007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86008       };
86009     } catch (std::exception& e) {
86010       {
86011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86016       };
86017     }
86018   }
86019 }
86020
86021
86022 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86023   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86024   unsigned int *arg2 = 0 ;
86025   unsigned int temp2 ;
86026
86027   arg1 = (std::vector< unsigned int > *)jarg1;
86028   temp2 = (unsigned int)jarg2;
86029   arg2 = &temp2;
86030   {
86031     try {
86032       (arg1)->push_back((unsigned int const &)*arg2);
86033     } catch (std::out_of_range& e) {
86034       {
86035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86036       };
86037     } catch (std::exception& e) {
86038       {
86039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86040       };
86041     } catch (...) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86044       };
86045     }
86046   }
86047 }
86048
86049
86050 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemIdContainer_size(void * jarg1) {
86051   unsigned long jresult ;
86052   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86053   std::vector< unsigned int >::size_type result;
86054
86055   arg1 = (std::vector< unsigned int > *)jarg1;
86056   {
86057     try {
86058       result = ((std::vector< unsigned int > const *)arg1)->size();
86059     } catch (std::out_of_range& e) {
86060       {
86061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (std::exception& e) {
86064       {
86065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073   jresult = (unsigned long)result;
86074   return jresult;
86075 }
86076
86077
86078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemIdContainer_capacity(void * jarg1) {
86079   unsigned long jresult ;
86080   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86081   std::vector< unsigned int >::size_type result;
86082
86083   arg1 = (std::vector< unsigned int > *)jarg1;
86084   {
86085     try {
86086       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86087     } catch (std::out_of_range& e) {
86088       {
86089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86090       };
86091     } catch (std::exception& e) {
86092       {
86093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (...) {
86096       {
86097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86098       };
86099     }
86100   }
86101   jresult = (unsigned long)result;
86102   return jresult;
86103 }
86104
86105
86106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86107   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86108   std::vector< unsigned int >::size_type arg2 ;
86109
86110   arg1 = (std::vector< unsigned int > *)jarg1;
86111   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86112   {
86113     try {
86114       (arg1)->reserve(arg2);
86115     } catch (std::out_of_range& e) {
86116       {
86117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86118       };
86119     } catch (std::exception& e) {
86120       {
86121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86122       };
86123     } catch (...) {
86124       {
86125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86126       };
86127     }
86128   }
86129 }
86130
86131
86132 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_0() {
86133   void * jresult ;
86134   std::vector< unsigned int > *result = 0 ;
86135
86136   {
86137     try {
86138       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86139     } catch (std::out_of_range& e) {
86140       {
86141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86142       };
86143     } catch (std::exception& e) {
86144       {
86145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86146       };
86147     } catch (...) {
86148       {
86149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86150       };
86151     }
86152   }
86153   jresult = (void *)result;
86154   return jresult;
86155 }
86156
86157
86158 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_1(void * jarg1) {
86159   void * jresult ;
86160   std::vector< unsigned int > *arg1 = 0 ;
86161   std::vector< unsigned int > *result = 0 ;
86162
86163   arg1 = (std::vector< unsigned int > *)jarg1;
86164   if (!arg1) {
86165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86166     return 0;
86167   }
86168   {
86169     try {
86170       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86171     } catch (std::out_of_range& e) {
86172       {
86173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86174       };
86175     } catch (std::exception& e) {
86176       {
86177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86178       };
86179     } catch (...) {
86180       {
86181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86182       };
86183     }
86184   }
86185   jresult = (void *)result;
86186   return jresult;
86187 }
86188
86189
86190 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_2(int jarg1) {
86191   void * jresult ;
86192   int arg1 ;
86193   std::vector< unsigned int > *result = 0 ;
86194
86195   arg1 = (int)jarg1;
86196   {
86197     try {
86198       try {
86199         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86200       }
86201       catch(std::out_of_range &_e) {
86202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86203         return 0;
86204       }
86205
86206     } catch (std::out_of_range& e) {
86207       {
86208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86209       };
86210     } catch (std::exception& e) {
86211       {
86212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86213       };
86214     } catch (...) {
86215       {
86216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86217       };
86218     }
86219   }
86220   jresult = (void *)result;
86221   return jresult;
86222 }
86223
86224
86225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86226   unsigned int jresult ;
86227   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86228   int arg2 ;
86229   unsigned int result;
86230
86231   arg1 = (std::vector< unsigned int > *)jarg1;
86232   arg2 = (int)jarg2;
86233   {
86234     try {
86235       try {
86236         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86237       }
86238       catch(std::out_of_range &_e) {
86239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86240         return 0;
86241       }
86242
86243     } catch (std::out_of_range& e) {
86244       {
86245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86246       };
86247     } catch (std::exception& e) {
86248       {
86249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86250       };
86251     } catch (...) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86254       };
86255     }
86256   }
86257   jresult = result;
86258   return jresult;
86259 }
86260
86261
86262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86263   unsigned int jresult ;
86264   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86265   int arg2 ;
86266   unsigned int *result = 0 ;
86267
86268   arg1 = (std::vector< unsigned int > *)jarg1;
86269   arg2 = (int)jarg2;
86270   {
86271     try {
86272       try {
86273         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86274       }
86275       catch(std::out_of_range &_e) {
86276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86277         return 0;
86278       }
86279
86280     } catch (std::out_of_range& e) {
86281       {
86282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86283       };
86284     } catch (std::exception& e) {
86285       {
86286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (...) {
86289       {
86290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86291       };
86292     }
86293   }
86294   jresult = *result;
86295   return jresult;
86296 }
86297
86298
86299 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86300   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86301   int arg2 ;
86302   unsigned int *arg3 = 0 ;
86303   unsigned int temp3 ;
86304
86305   arg1 = (std::vector< unsigned int > *)jarg1;
86306   arg2 = (int)jarg2;
86307   temp3 = (unsigned int)jarg3;
86308   arg3 = &temp3;
86309   {
86310     try {
86311       try {
86312         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86313       }
86314       catch(std::out_of_range &_e) {
86315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86316         return ;
86317       }
86318
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86326       };
86327     } catch (...) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86330       };
86331     }
86332   }
86333 }
86334
86335
86336 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86337   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86338   std::vector< unsigned int > *arg2 = 0 ;
86339
86340   arg1 = (std::vector< unsigned int > *)jarg1;
86341   arg2 = (std::vector< unsigned int > *)jarg2;
86342   if (!arg2) {
86343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86344     return ;
86345   }
86346   {
86347     try {
86348       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86349     } catch (std::out_of_range& e) {
86350       {
86351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86352       };
86353     } catch (std::exception& e) {
86354       {
86355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86356       };
86357     } catch (...) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86360       };
86361     }
86362   }
86363 }
86364
86365
86366 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86367   void * jresult ;
86368   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86369   int arg2 ;
86370   int arg3 ;
86371   std::vector< unsigned int > *result = 0 ;
86372
86373   arg1 = (std::vector< unsigned int > *)jarg1;
86374   arg2 = (int)jarg2;
86375   arg3 = (int)jarg3;
86376   {
86377     try {
86378       try {
86379         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86380       }
86381       catch(std::out_of_range &_e) {
86382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86383         return 0;
86384       }
86385       catch(std::invalid_argument &_e) {
86386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86387         return 0;
86388       }
86389
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (...) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86401       };
86402     }
86403   }
86404   jresult = (void *)result;
86405   return jresult;
86406 }
86407
86408
86409 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86411   int arg2 ;
86412   unsigned int *arg3 = 0 ;
86413   unsigned int temp3 ;
86414
86415   arg1 = (std::vector< unsigned int > *)jarg1;
86416   arg2 = (int)jarg2;
86417   temp3 = (unsigned int)jarg3;
86418   arg3 = &temp3;
86419   {
86420     try {
86421       try {
86422         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86423       }
86424       catch(std::out_of_range &_e) {
86425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86426         return ;
86427       }
86428
86429     } catch (std::out_of_range& e) {
86430       {
86431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86432       };
86433     } catch (std::exception& e) {
86434       {
86435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86436       };
86437     } catch (...) {
86438       {
86439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86440       };
86441     }
86442   }
86443 }
86444
86445
86446 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86447   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86448   int arg2 ;
86449   std::vector< unsigned int > *arg3 = 0 ;
86450
86451   arg1 = (std::vector< unsigned int > *)jarg1;
86452   arg2 = (int)jarg2;
86453   arg3 = (std::vector< unsigned int > *)jarg3;
86454   if (!arg3) {
86455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86456     return ;
86457   }
86458   {
86459     try {
86460       try {
86461         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86462       }
86463       catch(std::out_of_range &_e) {
86464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86465         return ;
86466       }
86467
86468     } catch (std::out_of_range& e) {
86469       {
86470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86471       };
86472     } catch (std::exception& e) {
86473       {
86474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86475       };
86476     } catch (...) {
86477       {
86478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86479       };
86480     }
86481   }
86482 }
86483
86484
86485 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86486   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86487   int arg2 ;
86488
86489   arg1 = (std::vector< unsigned int > *)jarg1;
86490   arg2 = (int)jarg2;
86491   {
86492     try {
86493       try {
86494         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86495       }
86496       catch(std::out_of_range &_e) {
86497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86498         return ;
86499       }
86500
86501     } catch (std::out_of_range& e) {
86502       {
86503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86504       };
86505     } catch (std::exception& e) {
86506       {
86507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86508       };
86509     } catch (...) {
86510       {
86511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86512       };
86513     }
86514   }
86515 }
86516
86517
86518 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86519   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86520   int arg2 ;
86521   int arg3 ;
86522
86523   arg1 = (std::vector< unsigned int > *)jarg1;
86524   arg2 = (int)jarg2;
86525   arg3 = (int)jarg3;
86526   {
86527     try {
86528       try {
86529         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86530       }
86531       catch(std::out_of_range &_e) {
86532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86533         return ;
86534       }
86535       catch(std::invalid_argument &_e) {
86536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86537         return ;
86538       }
86539
86540     } catch (std::out_of_range& e) {
86541       {
86542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86543       };
86544     } catch (std::exception& e) {
86545       {
86546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86551       };
86552     }
86553   }
86554 }
86555
86556
86557 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86558   void * jresult ;
86559   unsigned int *arg1 = 0 ;
86560   int arg2 ;
86561   unsigned int temp1 ;
86562   std::vector< unsigned int > *result = 0 ;
86563
86564   temp1 = (unsigned int)jarg1;
86565   arg1 = &temp1;
86566   arg2 = (int)jarg2;
86567   {
86568     try {
86569       try {
86570         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86571       }
86572       catch(std::out_of_range &_e) {
86573         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86574         return 0;
86575       }
86576
86577     } catch (std::out_of_range& e) {
86578       {
86579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86580       };
86581     } catch (std::exception& e) {
86582       {
86583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86584       };
86585     } catch (...) {
86586       {
86587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86588       };
86589     }
86590   }
86591   jresult = (void *)result;
86592   return jresult;
86593 }
86594
86595
86596 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86597   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86598
86599   arg1 = (std::vector< unsigned int > *)jarg1;
86600   {
86601     try {
86602       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86603     } catch (std::out_of_range& e) {
86604       {
86605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86606       };
86607     } catch (std::exception& e) {
86608       {
86609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86610       };
86611     } catch (...) {
86612       {
86613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86614       };
86615     }
86616   }
86617 }
86618
86619
86620 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86621   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86622   int arg2 ;
86623   int arg3 ;
86624
86625   arg1 = (std::vector< unsigned int > *)jarg1;
86626   arg2 = (int)jarg2;
86627   arg3 = (int)jarg3;
86628   {
86629     try {
86630       try {
86631         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86632       }
86633       catch(std::out_of_range &_e) {
86634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86635         return ;
86636       }
86637       catch(std::invalid_argument &_e) {
86638         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86639         return ;
86640       }
86641
86642     } catch (std::out_of_range& e) {
86643       {
86644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86645       };
86646     } catch (std::exception& e) {
86647       {
86648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86649       };
86650     } catch (...) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86653       };
86654     }
86655   }
86656 }
86657
86658
86659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86660   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86661   int arg2 ;
86662   std::vector< unsigned int > *arg3 = 0 ;
86663
86664   arg1 = (std::vector< unsigned int > *)jarg1;
86665   arg2 = (int)jarg2;
86666   arg3 = (std::vector< unsigned int > *)jarg3;
86667   if (!arg3) {
86668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86669     return ;
86670   }
86671   {
86672     try {
86673       try {
86674         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86675       }
86676       catch(std::out_of_range &_e) {
86677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86678         return ;
86679       }
86680
86681     } catch (std::out_of_range& e) {
86682       {
86683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86684       };
86685     } catch (std::exception& e) {
86686       {
86687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86688       };
86689     } catch (...) {
86690       {
86691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86692       };
86693     }
86694   }
86695 }
86696
86697
86698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86699   unsigned int jresult ;
86700   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86701   unsigned int *arg2 = 0 ;
86702   unsigned int temp2 ;
86703   bool result;
86704
86705   arg1 = (std::vector< unsigned int > *)jarg1;
86706   temp2 = (unsigned int)jarg2;
86707   arg2 = &temp2;
86708   {
86709     try {
86710       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86711     } catch (std::out_of_range& e) {
86712       {
86713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86714       };
86715     } catch (std::exception& e) {
86716       {
86717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86718       };
86719     } catch (...) {
86720       {
86721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86722       };
86723     }
86724   }
86725   jresult = result;
86726   return jresult;
86727 }
86728
86729
86730 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86731   int jresult ;
86732   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86733   unsigned int *arg2 = 0 ;
86734   unsigned int temp2 ;
86735   int result;
86736
86737   arg1 = (std::vector< unsigned int > *)jarg1;
86738   temp2 = (unsigned int)jarg2;
86739   arg2 = &temp2;
86740   {
86741     try {
86742       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86743     } catch (std::out_of_range& e) {
86744       {
86745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86746       };
86747     } catch (std::exception& e) {
86748       {
86749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86750       };
86751     } catch (...) {
86752       {
86753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86754       };
86755     }
86756   }
86757   jresult = result;
86758   return jresult;
86759 }
86760
86761
86762 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86763   int jresult ;
86764   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86765   unsigned int *arg2 = 0 ;
86766   unsigned int temp2 ;
86767   int result;
86768
86769   arg1 = (std::vector< unsigned int > *)jarg1;
86770   temp2 = (unsigned int)jarg2;
86771   arg2 = &temp2;
86772   {
86773     try {
86774       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86775     } catch (std::out_of_range& e) {
86776       {
86777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86778       };
86779     } catch (std::exception& e) {
86780       {
86781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86782       };
86783     } catch (...) {
86784       {
86785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86786       };
86787     }
86788   }
86789   jresult = result;
86790   return jresult;
86791 }
86792
86793
86794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86795   unsigned int jresult ;
86796   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86797   unsigned int *arg2 = 0 ;
86798   unsigned int temp2 ;
86799   bool result;
86800
86801   arg1 = (std::vector< unsigned int > *)jarg1;
86802   temp2 = (unsigned int)jarg2;
86803   arg2 = &temp2;
86804   {
86805     try {
86806       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86807     } catch (std::out_of_range& e) {
86808       {
86809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86810       };
86811     } catch (std::exception& e) {
86812       {
86813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86814       };
86815     } catch (...) {
86816       {
86817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86818       };
86819     }
86820   }
86821   jresult = result;
86822   return jresult;
86823 }
86824
86825
86826 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemIdContainer(void * jarg1) {
86827   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86828
86829   arg1 = (std::vector< unsigned int > *)jarg1;
86830   {
86831     try {
86832       delete arg1;
86833     } catch (std::out_of_range& e) {
86834       {
86835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86836       };
86837     } catch (std::exception& e) {
86838       {
86839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86840       };
86841     } catch (...) {
86842       {
86843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86844       };
86845     }
86846   }
86847 }
86848
86849
86850 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_0() {
86851   void * jresult ;
86852   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86853
86854   {
86855     try {
86856       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86857     } catch (std::out_of_range& e) {
86858       {
86859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86860       };
86861     } catch (std::exception& e) {
86862       {
86863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86864       };
86865     } catch (...) {
86866       {
86867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86868       };
86869     }
86870   }
86871   jresult = (void *)result;
86872   return jresult;
86873 }
86874
86875
86876 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86877   void * jresult ;
86878   unsigned int arg1 ;
86879   Dali::Actor arg2 ;
86880   Dali::Actor *argp2 ;
86881   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86882
86883   arg1 = (unsigned int)jarg1;
86884   argp2 = (Dali::Actor *)jarg2;
86885   if (!argp2) {
86886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86887     return 0;
86888   }
86889   arg2 = *argp2;
86890   {
86891     try {
86892       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86893     } catch (std::out_of_range& e) {
86894       {
86895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86896       };
86897     } catch (std::exception& e) {
86898       {
86899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86900       };
86901     } catch (...) {
86902       {
86903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86904       };
86905     }
86906   }
86907   jresult = (void *)result;
86908   return jresult;
86909 }
86910
86911
86912 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_2(void * jarg1) {
86913   void * jresult ;
86914   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86915   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86916
86917   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86918   if (!arg1) {
86919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86920     return 0;
86921   }
86922   {
86923     try {
86924       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86925     } catch (std::out_of_range& e) {
86926       {
86927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86928       };
86929     } catch (std::exception& e) {
86930       {
86931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86932       };
86933     } catch (...) {
86934       {
86935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86936       };
86937     }
86938   }
86939   jresult = (void *)result;
86940   return jresult;
86941 }
86942
86943
86944 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Item_first_set(void * jarg1, unsigned int jarg2) {
86945   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86946   unsigned int arg2 ;
86947
86948   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86949   arg2 = (unsigned int)jarg2;
86950   if (arg1) (arg1)->first = arg2;
86951 }
86952
86953
86954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Item_first_get(void * jarg1) {
86955   unsigned int jresult ;
86956   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86957   unsigned int result;
86958
86959   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86960   result = (unsigned int) ((arg1)->first);
86961   jresult = result;
86962   return jresult;
86963 }
86964
86965
86966 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Item_second_set(void * jarg1, void * jarg2) {
86967   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86968   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86969
86970   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86971   arg2 = (Dali::Actor *)jarg2;
86972   if (arg1) (arg1)->second = *arg2;
86973 }
86974
86975
86976 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Item_second_get(void * jarg1) {
86977   void * jresult ;
86978   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86979   Dali::Actor *result = 0 ;
86980
86981   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86982   result = (Dali::Actor *)& ((arg1)->second);
86983   jresult = (void *)result;
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Item(void * jarg1) {
86989   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86990
86991   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86992   {
86993     try {
86994       delete arg1;
86995     } catch (std::out_of_range& e) {
86996       {
86997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86998       };
86999     } catch (std::exception& e) {
87000       {
87001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87002       };
87003     } catch (...) {
87004       {
87005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87006       };
87007     }
87008   }
87009 }
87010
87011
87012 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Clear(void * jarg1) {
87013   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87014
87015   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87016   {
87017     try {
87018       (arg1)->clear();
87019     } catch (std::out_of_range& e) {
87020       {
87021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87022       };
87023     } catch (std::exception& e) {
87024       {
87025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87026       };
87027     } catch (...) {
87028       {
87029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87030       };
87031     }
87032   }
87033 }
87034
87035
87036 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Add(void * jarg1, void * jarg2) {
87037   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87038   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87039
87040   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87041   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87042   if (!arg2) {
87043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87044     return ;
87045   }
87046   {
87047     try {
87048       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87049     } catch (std::out_of_range& e) {
87050       {
87051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87052       };
87053     } catch (std::exception& e) {
87054       {
87055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87056       };
87057     } catch (...) {
87058       {
87059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87060       };
87061     }
87062   }
87063 }
87064
87065
87066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemContainer_size(void * jarg1) {
87067   unsigned long jresult ;
87068   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87069   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87070
87071   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87072   {
87073     try {
87074       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87075     } catch (std::out_of_range& e) {
87076       {
87077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87078       };
87079     } catch (std::exception& e) {
87080       {
87081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87082       };
87083     } catch (...) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87086       };
87087     }
87088   }
87089   jresult = (unsigned long)result;
87090   return jresult;
87091 }
87092
87093
87094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemContainer_capacity(void * jarg1) {
87095   unsigned long jresult ;
87096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87097   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87098
87099   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87100   {
87101     try {
87102       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87103     } catch (std::out_of_range& e) {
87104       {
87105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (std::exception& e) {
87108       {
87109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (...) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87114       };
87115     }
87116   }
87117   jresult = (unsigned long)result;
87118   return jresult;
87119 }
87120
87121
87122 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87123   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87124   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87125
87126   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87127   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87128   {
87129     try {
87130       (arg1)->reserve(arg2);
87131     } catch (std::out_of_range& e) {
87132       {
87133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87134       };
87135     } catch (std::exception& e) {
87136       {
87137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87138       };
87139     } catch (...) {
87140       {
87141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87142       };
87143     }
87144   }
87145 }
87146
87147
87148 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_0() {
87149   void * jresult ;
87150   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87151
87152   {
87153     try {
87154       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87155     } catch (std::out_of_range& e) {
87156       {
87157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (std::exception& e) {
87160       {
87161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87162       };
87163     } catch (...) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87166       };
87167     }
87168   }
87169   jresult = (void *)result;
87170   return jresult;
87171 }
87172
87173
87174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_1(void * jarg1) {
87175   void * jresult ;
87176   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87177   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87178
87179   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87180   if (!arg1) {
87181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87182     return 0;
87183   }
87184   {
87185     try {
87186       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);
87187     } catch (std::out_of_range& e) {
87188       {
87189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87190       };
87191     } catch (std::exception& e) {
87192       {
87193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87194       };
87195     } catch (...) {
87196       {
87197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87198       };
87199     }
87200   }
87201   jresult = (void *)result;
87202   return jresult;
87203 }
87204
87205
87206 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_2(int jarg1) {
87207   void * jresult ;
87208   int arg1 ;
87209   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87210
87211   arg1 = (int)jarg1;
87212   {
87213     try {
87214       try {
87215         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);
87216       }
87217       catch(std::out_of_range &_e) {
87218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87219         return 0;
87220       }
87221
87222     } catch (std::out_of_range& e) {
87223       {
87224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87225       };
87226     } catch (std::exception& e) {
87227       {
87228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87229       };
87230     } catch (...) {
87231       {
87232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87233       };
87234     }
87235   }
87236   jresult = (void *)result;
87237   return jresult;
87238 }
87239
87240
87241 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87242   void * jresult ;
87243   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87244   int arg2 ;
87245   std::pair< unsigned int,Dali::Actor > result;
87246
87247   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87248   arg2 = (int)jarg2;
87249   {
87250     try {
87251       try {
87252         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87253       }
87254       catch(std::out_of_range &_e) {
87255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87256         return 0;
87257       }
87258
87259     } catch (std::out_of_range& e) {
87260       {
87261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87262       };
87263     } catch (std::exception& e) {
87264       {
87265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87266       };
87267     } catch (...) {
87268       {
87269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87270       };
87271     }
87272   }
87273   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87274   return jresult;
87275 }
87276
87277
87278 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_getitem(void * jarg1, int jarg2) {
87279   void * jresult ;
87280   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87281   int arg2 ;
87282   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87283
87284   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87285   arg2 = (int)jarg2;
87286   {
87287     try {
87288       try {
87289         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87290       }
87291       catch(std::out_of_range &_e) {
87292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87293         return 0;
87294       }
87295
87296     } catch (std::out_of_range& e) {
87297       {
87298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87299       };
87300     } catch (std::exception& e) {
87301       {
87302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87303       };
87304     } catch (...) {
87305       {
87306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87307       };
87308     }
87309   }
87310   jresult = (void *)result;
87311   return jresult;
87312 }
87313
87314
87315 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87316   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87317   int arg2 ;
87318   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87319
87320   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87321   arg2 = (int)jarg2;
87322   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87323   if (!arg3) {
87324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87325     return ;
87326   }
87327   {
87328     try {
87329       try {
87330         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);
87331       }
87332       catch(std::out_of_range &_e) {
87333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87334         return ;
87335       }
87336
87337     } catch (std::out_of_range& e) {
87338       {
87339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87340       };
87341     } catch (std::exception& e) {
87342       {
87343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87344       };
87345     } catch (...) {
87346       {
87347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87348       };
87349     }
87350   }
87351 }
87352
87353
87354 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87355   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87356   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87357
87358   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87359   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87360   if (!arg2) {
87361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87362     return ;
87363   }
87364   {
87365     try {
87366       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);
87367     } catch (std::out_of_range& e) {
87368       {
87369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87370       };
87371     } catch (std::exception& e) {
87372       {
87373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87374       };
87375     } catch (...) {
87376       {
87377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87378       };
87379     }
87380   }
87381 }
87382
87383
87384 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87385   void * jresult ;
87386   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87387   int arg2 ;
87388   int arg3 ;
87389   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87390
87391   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87392   arg2 = (int)jarg2;
87393   arg3 = (int)jarg3;
87394   {
87395     try {
87396       try {
87397         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);
87398       }
87399       catch(std::out_of_range &_e) {
87400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87401         return 0;
87402       }
87403       catch(std::invalid_argument &_e) {
87404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87405         return 0;
87406       }
87407
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87415       };
87416     } catch (...) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87419       };
87420     }
87421   }
87422   jresult = (void *)result;
87423   return jresult;
87424 }
87425
87426
87427 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87429   int arg2 ;
87430   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87431
87432   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87433   arg2 = (int)jarg2;
87434   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87435   if (!arg3) {
87436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87437     return ;
87438   }
87439   {
87440     try {
87441       try {
87442         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);
87443       }
87444       catch(std::out_of_range &_e) {
87445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87446         return ;
87447       }
87448
87449     } catch (std::out_of_range& e) {
87450       {
87451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87452       };
87453     } catch (std::exception& e) {
87454       {
87455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87456       };
87457     } catch (...) {
87458       {
87459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87460       };
87461     }
87462   }
87463 }
87464
87465
87466 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87467   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87468   int arg2 ;
87469   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87470
87471   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87472   arg2 = (int)jarg2;
87473   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87474   if (!arg3) {
87475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87476     return ;
87477   }
87478   {
87479     try {
87480       try {
87481         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);
87482       }
87483       catch(std::out_of_range &_e) {
87484         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87485         return ;
87486       }
87487
87488     } catch (std::out_of_range& e) {
87489       {
87490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87491       };
87492     } catch (std::exception& e) {
87493       {
87494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87495       };
87496     } catch (...) {
87497       {
87498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87499       };
87500     }
87501   }
87502 }
87503
87504
87505 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87506   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87507   int arg2 ;
87508
87509   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87510   arg2 = (int)jarg2;
87511   {
87512     try {
87513       try {
87514         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87515       }
87516       catch(std::out_of_range &_e) {
87517         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87518         return ;
87519       }
87520
87521     } catch (std::out_of_range& e) {
87522       {
87523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87524       };
87525     } catch (std::exception& e) {
87526       {
87527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87528       };
87529     } catch (...) {
87530       {
87531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87532       };
87533     }
87534   }
87535 }
87536
87537
87538 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87539   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87540   int arg2 ;
87541   int arg3 ;
87542
87543   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87544   arg2 = (int)jarg2;
87545   arg3 = (int)jarg3;
87546   {
87547     try {
87548       try {
87549         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87550       }
87551       catch(std::out_of_range &_e) {
87552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87553         return ;
87554       }
87555       catch(std::invalid_argument &_e) {
87556         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87557         return ;
87558       }
87559
87560     } catch (std::out_of_range& e) {
87561       {
87562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87563       };
87564     } catch (std::exception& e) {
87565       {
87566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87567       };
87568     } catch (...) {
87569       {
87570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87571       };
87572     }
87573   }
87574 }
87575
87576
87577 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_Repeat(void * jarg1, int jarg2) {
87578   void * jresult ;
87579   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87580   int arg2 ;
87581   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87582
87583   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87584   if (!arg1) {
87585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87586     return 0;
87587   }
87588   arg2 = (int)jarg2;
87589   {
87590     try {
87591       try {
87592         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);
87593       }
87594       catch(std::out_of_range &_e) {
87595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87596         return 0;
87597       }
87598
87599     } catch (std::out_of_range& e) {
87600       {
87601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87602       };
87603     } catch (std::exception& e) {
87604       {
87605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87606       };
87607     } catch (...) {
87608       {
87609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87610       };
87611     }
87612   }
87613   jresult = (void *)result;
87614   return jresult;
87615 }
87616
87617
87618 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87619   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87620
87621   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87622   {
87623     try {
87624       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87625     } catch (std::out_of_range& e) {
87626       {
87627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87628       };
87629     } catch (std::exception& e) {
87630       {
87631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87632       };
87633     } catch (...) {
87634       {
87635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87636       };
87637     }
87638   }
87639 }
87640
87641
87642 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87643   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87644   int arg2 ;
87645   int arg3 ;
87646
87647   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87648   arg2 = (int)jarg2;
87649   arg3 = (int)jarg3;
87650   {
87651     try {
87652       try {
87653         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87654       }
87655       catch(std::out_of_range &_e) {
87656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87657         return ;
87658       }
87659       catch(std::invalid_argument &_e) {
87660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87661         return ;
87662       }
87663
87664     } catch (std::out_of_range& e) {
87665       {
87666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87667       };
87668     } catch (std::exception& e) {
87669       {
87670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87671       };
87672     } catch (...) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87675       };
87676     }
87677   }
87678 }
87679
87680
87681 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87682   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87683   int arg2 ;
87684   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87685
87686   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87687   arg2 = (int)jarg2;
87688   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87689   if (!arg3) {
87690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87691     return ;
87692   }
87693   {
87694     try {
87695       try {
87696         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);
87697       }
87698       catch(std::out_of_range &_e) {
87699         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87700         return ;
87701       }
87702
87703     } catch (std::out_of_range& e) {
87704       {
87705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87706       };
87707     } catch (std::exception& e) {
87708       {
87709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87710       };
87711     } catch (...) {
87712       {
87713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87714       };
87715     }
87716   }
87717 }
87718
87719
87720 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemContainer(void * jarg1) {
87721   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87722
87723   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87724   {
87725     try {
87726       delete arg1;
87727     } catch (std::out_of_range& e) {
87728       {
87729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87730       };
87731     } catch (std::exception& e) {
87732       {
87733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87734       };
87735     } catch (...) {
87736       {
87737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87738       };
87739     }
87740   }
87741 }
87742
87743
87744 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Clear(void * jarg1) {
87745   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87746
87747   arg1 = (std::vector< Dali::Actor > *)jarg1;
87748   {
87749     try {
87750       (arg1)->clear();
87751     } catch (std::out_of_range& e) {
87752       {
87753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87754       };
87755     } catch (std::exception& e) {
87756       {
87757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87758       };
87759     } catch (...) {
87760       {
87761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87762       };
87763     }
87764   }
87765 }
87766
87767
87768 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Add(void * jarg1, void * jarg2) {
87769   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87770   Dali::Actor *arg2 = 0 ;
87771
87772   arg1 = (std::vector< Dali::Actor > *)jarg1;
87773   arg2 = (Dali::Actor *)jarg2;
87774   if (!arg2) {
87775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87776     return ;
87777   }
87778   {
87779     try {
87780       (arg1)->push_back((Dali::Actor const &)*arg2);
87781     } catch (std::out_of_range& e) {
87782       {
87783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87784       };
87785     } catch (std::exception& e) {
87786       {
87787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87788       };
87789     } catch (...) {
87790       {
87791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87792       };
87793     }
87794   }
87795 }
87796
87797
87798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorContainer_size(void * jarg1) {
87799   unsigned long jresult ;
87800   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87801   std::vector< Dali::Actor >::size_type result;
87802
87803   arg1 = (std::vector< Dali::Actor > *)jarg1;
87804   {
87805     try {
87806       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87814       };
87815     } catch (...) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87818       };
87819     }
87820   }
87821   jresult = (unsigned long)result;
87822   return jresult;
87823 }
87824
87825
87826 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorContainer_capacity(void * jarg1) {
87827   unsigned long jresult ;
87828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87829   std::vector< Dali::Actor >::size_type result;
87830
87831   arg1 = (std::vector< Dali::Actor > *)jarg1;
87832   {
87833     try {
87834       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87835     } catch (std::out_of_range& e) {
87836       {
87837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87838       };
87839     } catch (std::exception& e) {
87840       {
87841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87842       };
87843     } catch (...) {
87844       {
87845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87846       };
87847     }
87848   }
87849   jresult = (unsigned long)result;
87850   return jresult;
87851 }
87852
87853
87854 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87855   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87856   std::vector< Dali::Actor >::size_type arg2 ;
87857
87858   arg1 = (std::vector< Dali::Actor > *)jarg1;
87859   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87860   {
87861     try {
87862       (arg1)->reserve(arg2);
87863     } catch (std::out_of_range& e) {
87864       {
87865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87866       };
87867     } catch (std::exception& e) {
87868       {
87869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87870       };
87871     } catch (...) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87874       };
87875     }
87876   }
87877 }
87878
87879
87880 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_0() {
87881   void * jresult ;
87882   std::vector< Dali::Actor > *result = 0 ;
87883
87884   {
87885     try {
87886       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87887     } catch (std::out_of_range& e) {
87888       {
87889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87890       };
87891     } catch (std::exception& e) {
87892       {
87893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87894       };
87895     } catch (...) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87898       };
87899     }
87900   }
87901   jresult = (void *)result;
87902   return jresult;
87903 }
87904
87905
87906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_1(void * jarg1) {
87907   void * jresult ;
87908   std::vector< Dali::Actor > *arg1 = 0 ;
87909   std::vector< Dali::Actor > *result = 0 ;
87910
87911   arg1 = (std::vector< Dali::Actor > *)jarg1;
87912   if (!arg1) {
87913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87914     return 0;
87915   }
87916   {
87917     try {
87918       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87919     } catch (std::out_of_range& e) {
87920       {
87921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87922       };
87923     } catch (std::exception& e) {
87924       {
87925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87926       };
87927     } catch (...) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87930       };
87931     }
87932   }
87933   jresult = (void *)result;
87934   return jresult;
87935 }
87936
87937
87938 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_2(int jarg1) {
87939   void * jresult ;
87940   int arg1 ;
87941   std::vector< Dali::Actor > *result = 0 ;
87942
87943   arg1 = (int)jarg1;
87944   {
87945     try {
87946       try {
87947         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87948       }
87949       catch(std::out_of_range &_e) {
87950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87951         return 0;
87952       }
87953
87954     } catch (std::out_of_range& e) {
87955       {
87956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87957       };
87958     } catch (std::exception& e) {
87959       {
87960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87961       };
87962     } catch (...) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87965       };
87966     }
87967   }
87968   jresult = (void *)result;
87969   return jresult;
87970 }
87971
87972
87973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87974   void * jresult ;
87975   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87976   int arg2 ;
87977   Dali::Actor result;
87978
87979   arg1 = (std::vector< Dali::Actor > *)jarg1;
87980   arg2 = (int)jarg2;
87981   {
87982     try {
87983       try {
87984         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87985       }
87986       catch(std::out_of_range &_e) {
87987         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87988         return 0;
87989       }
87990
87991     } catch (std::out_of_range& e) {
87992       {
87993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87994       };
87995     } catch (std::exception& e) {
87996       {
87997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88002       };
88003     }
88004   }
88005   jresult = new Dali::Actor((const Dali::Actor &)result);
88006   return jresult;
88007 }
88008
88009
88010 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_getitem(void * jarg1, int jarg2) {
88011   void * jresult ;
88012   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88013   int arg2 ;
88014   Dali::Actor *result = 0 ;
88015
88016   arg1 = (std::vector< Dali::Actor > *)jarg1;
88017   arg2 = (int)jarg2;
88018   {
88019     try {
88020       try {
88021         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88022       }
88023       catch(std::out_of_range &_e) {
88024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88025         return 0;
88026       }
88027
88028     } catch (std::out_of_range& e) {
88029       {
88030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88031       };
88032     } catch (std::exception& e) {
88033       {
88034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88035       };
88036     } catch (...) {
88037       {
88038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88039       };
88040     }
88041   }
88042   jresult = (void *)result;
88043   return jresult;
88044 }
88045
88046
88047 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88048   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88049   int arg2 ;
88050   Dali::Actor *arg3 = 0 ;
88051
88052   arg1 = (std::vector< Dali::Actor > *)jarg1;
88053   arg2 = (int)jarg2;
88054   arg3 = (Dali::Actor *)jarg3;
88055   if (!arg3) {
88056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88057     return ;
88058   }
88059   {
88060     try {
88061       try {
88062         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88063       }
88064       catch(std::out_of_range &_e) {
88065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88066         return ;
88067       }
88068
88069     } catch (std::out_of_range& e) {
88070       {
88071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88072       };
88073     } catch (std::exception& e) {
88074       {
88075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88080       };
88081     }
88082   }
88083 }
88084
88085
88086 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88087   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88088   std::vector< Dali::Actor > *arg2 = 0 ;
88089
88090   arg1 = (std::vector< Dali::Actor > *)jarg1;
88091   arg2 = (std::vector< Dali::Actor > *)jarg2;
88092   if (!arg2) {
88093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88094     return ;
88095   }
88096   {
88097     try {
88098       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88099     } catch (std::out_of_range& e) {
88100       {
88101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88102       };
88103     } catch (std::exception& e) {
88104       {
88105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88106       };
88107     } catch (...) {
88108       {
88109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88110       };
88111     }
88112   }
88113 }
88114
88115
88116 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88117   void * jresult ;
88118   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88119   int arg2 ;
88120   int arg3 ;
88121   std::vector< Dali::Actor > *result = 0 ;
88122
88123   arg1 = (std::vector< Dali::Actor > *)jarg1;
88124   arg2 = (int)jarg2;
88125   arg3 = (int)jarg3;
88126   {
88127     try {
88128       try {
88129         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88130       }
88131       catch(std::out_of_range &_e) {
88132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88133         return 0;
88134       }
88135       catch(std::invalid_argument &_e) {
88136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88137         return 0;
88138       }
88139
88140     } catch (std::out_of_range& e) {
88141       {
88142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88143       };
88144     } catch (std::exception& e) {
88145       {
88146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88147       };
88148     } catch (...) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88151       };
88152     }
88153   }
88154   jresult = (void *)result;
88155   return jresult;
88156 }
88157
88158
88159 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88160   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88161   int arg2 ;
88162   Dali::Actor *arg3 = 0 ;
88163
88164   arg1 = (std::vector< Dali::Actor > *)jarg1;
88165   arg2 = (int)jarg2;
88166   arg3 = (Dali::Actor *)jarg3;
88167   if (!arg3) {
88168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88169     return ;
88170   }
88171   {
88172     try {
88173       try {
88174         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88175       }
88176       catch(std::out_of_range &_e) {
88177         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88178         return ;
88179       }
88180
88181     } catch (std::out_of_range& e) {
88182       {
88183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88184       };
88185     } catch (std::exception& e) {
88186       {
88187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88188       };
88189     } catch (...) {
88190       {
88191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88192       };
88193     }
88194   }
88195 }
88196
88197
88198 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88199   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88200   int arg2 ;
88201   std::vector< Dali::Actor > *arg3 = 0 ;
88202
88203   arg1 = (std::vector< Dali::Actor > *)jarg1;
88204   arg2 = (int)jarg2;
88205   arg3 = (std::vector< Dali::Actor > *)jarg3;
88206   if (!arg3) {
88207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88208     return ;
88209   }
88210   {
88211     try {
88212       try {
88213         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88214       }
88215       catch(std::out_of_range &_e) {
88216         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88217         return ;
88218       }
88219
88220     } catch (std::out_of_range& e) {
88221       {
88222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88223       };
88224     } catch (std::exception& e) {
88225       {
88226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88227       };
88228     } catch (...) {
88229       {
88230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88231       };
88232     }
88233   }
88234 }
88235
88236
88237 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88238   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88239   int arg2 ;
88240
88241   arg1 = (std::vector< Dali::Actor > *)jarg1;
88242   arg2 = (int)jarg2;
88243   {
88244     try {
88245       try {
88246         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88247       }
88248       catch(std::out_of_range &_e) {
88249         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88250         return ;
88251       }
88252
88253     } catch (std::out_of_range& e) {
88254       {
88255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88256       };
88257     } catch (std::exception& e) {
88258       {
88259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88260       };
88261     } catch (...) {
88262       {
88263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88264       };
88265     }
88266   }
88267 }
88268
88269
88270 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88271   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88272   int arg2 ;
88273   int arg3 ;
88274
88275   arg1 = (std::vector< Dali::Actor > *)jarg1;
88276   arg2 = (int)jarg2;
88277   arg3 = (int)jarg3;
88278   {
88279     try {
88280       try {
88281         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88282       }
88283       catch(std::out_of_range &_e) {
88284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88285         return ;
88286       }
88287       catch(std::invalid_argument &_e) {
88288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88289         return ;
88290       }
88291
88292     } catch (std::out_of_range& e) {
88293       {
88294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88295       };
88296     } catch (std::exception& e) {
88297       {
88298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88299       };
88300     } catch (...) {
88301       {
88302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88303       };
88304     }
88305   }
88306 }
88307
88308
88309 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_Repeat(void * jarg1, int jarg2) {
88310   void * jresult ;
88311   Dali::Actor *arg1 = 0 ;
88312   int arg2 ;
88313   std::vector< Dali::Actor > *result = 0 ;
88314
88315   arg1 = (Dali::Actor *)jarg1;
88316   if (!arg1) {
88317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88318     return 0;
88319   }
88320   arg2 = (int)jarg2;
88321   {
88322     try {
88323       try {
88324         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88325       }
88326       catch(std::out_of_range &_e) {
88327         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88328         return 0;
88329       }
88330
88331     } catch (std::out_of_range& e) {
88332       {
88333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88334       };
88335     } catch (std::exception& e) {
88336       {
88337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88338       };
88339     } catch (...) {
88340       {
88341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88342       };
88343     }
88344   }
88345   jresult = (void *)result;
88346   return jresult;
88347 }
88348
88349
88350 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88351   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88352
88353   arg1 = (std::vector< Dali::Actor > *)jarg1;
88354   {
88355     try {
88356       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88357     } catch (std::out_of_range& e) {
88358       {
88359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88360       };
88361     } catch (std::exception& e) {
88362       {
88363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88364       };
88365     } catch (...) {
88366       {
88367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88368       };
88369     }
88370   }
88371 }
88372
88373
88374 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88375   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88376   int arg2 ;
88377   int arg3 ;
88378
88379   arg1 = (std::vector< Dali::Actor > *)jarg1;
88380   arg2 = (int)jarg2;
88381   arg3 = (int)jarg3;
88382   {
88383     try {
88384       try {
88385         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88386       }
88387       catch(std::out_of_range &_e) {
88388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88389         return ;
88390       }
88391       catch(std::invalid_argument &_e) {
88392         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88393         return ;
88394       }
88395
88396     } catch (std::out_of_range& e) {
88397       {
88398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88399       };
88400     } catch (std::exception& e) {
88401       {
88402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88403       };
88404     } catch (...) {
88405       {
88406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88407       };
88408     }
88409   }
88410 }
88411
88412
88413 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88414   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88415   int arg2 ;
88416   std::vector< Dali::Actor > *arg3 = 0 ;
88417
88418   arg1 = (std::vector< Dali::Actor > *)jarg1;
88419   arg2 = (int)jarg2;
88420   arg3 = (std::vector< Dali::Actor > *)jarg3;
88421   if (!arg3) {
88422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88423     return ;
88424   }
88425   {
88426     try {
88427       try {
88428         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88429       }
88430       catch(std::out_of_range &_e) {
88431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88432         return ;
88433       }
88434
88435     } catch (std::out_of_range& e) {
88436       {
88437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88438       };
88439     } catch (std::exception& e) {
88440       {
88441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88442       };
88443     } catch (...) {
88444       {
88445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88446       };
88447     }
88448   }
88449 }
88450
88451
88452 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorContainer(void * jarg1) {
88453   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88454
88455   arg1 = (std::vector< Dali::Actor > *)jarg1;
88456   {
88457     try {
88458       delete arg1;
88459     } catch (std::out_of_range& e) {
88460       {
88461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88462       };
88463     } catch (std::exception& e) {
88464       {
88465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88466       };
88467     } catch (...) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88470       };
88471     }
88472   }
88473 }
88474
88475
88476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Empty(void * jarg1) {
88477   unsigned int jresult ;
88478   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88479   bool result;
88480
88481   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88482   {
88483     try {
88484       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88485     } catch (std::out_of_range& e) {
88486       {
88487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88488       };
88489     } catch (std::exception& e) {
88490       {
88491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88492       };
88493     } catch (...) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88496       };
88497     }
88498   }
88499   jresult = result;
88500   return jresult;
88501 }
88502
88503
88504 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88505   unsigned long jresult ;
88506   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88507   std::size_t result;
88508
88509   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88510   {
88511     try {
88512       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88513     } catch (std::out_of_range& e) {
88514       {
88515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88516       };
88517     } catch (std::exception& e) {
88518       {
88519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88520       };
88521     } catch (...) {
88522       {
88523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88524       };
88525     }
88526   }
88527   jresult = (unsigned long)result;
88528   return jresult;
88529 }
88530
88531
88532 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88533   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88534   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88535
88536   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88537   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88538   {
88539     try {
88540       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88541     } catch (std::out_of_range& e) {
88542       {
88543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88544       };
88545     } catch (std::exception& e) {
88546       {
88547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88548       };
88549     } catch (...) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88552       };
88553     }
88554   }
88555 }
88556
88557
88558 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88559   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88560   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88561
88562   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88563   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88564   {
88565     try {
88566       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88567     } catch (std::out_of_range& e) {
88568       {
88569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88570       };
88571     } catch (std::exception& e) {
88572       {
88573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88574       };
88575     } catch (...) {
88576       {
88577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88578       };
88579     }
88580   }
88581 }
88582
88583
88584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88585   unsigned int jresult ;
88586   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88587   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88588   bool result;
88589
88590   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88591   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88592   if (!arg2) {
88593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88594     return 0;
88595   }
88596   {
88597     try {
88598       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88599     } catch (std::out_of_range& e) {
88600       {
88601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88602       };
88603     } catch (std::exception& e) {
88604       {
88605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88606       };
88607     } catch (...) {
88608       {
88609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88610       };
88611     }
88612   }
88613   jresult = result;
88614   return jresult;
88615 }
88616
88617
88618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityActionSignal() {
88619   void * jresult ;
88620   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88621
88622   {
88623     try {
88624       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88625     } catch (std::out_of_range& e) {
88626       {
88627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88628       };
88629     } catch (std::exception& e) {
88630       {
88631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88632       };
88633     } catch (...) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88636       };
88637     }
88638   }
88639   jresult = (void *)result;
88640   return jresult;
88641 }
88642
88643
88644 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityActionSignal(void * jarg1) {
88645   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88646
88647   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88648   {
88649     try {
88650       delete arg1;
88651     } catch (std::out_of_range& e) {
88652       {
88653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88654       };
88655     } catch (std::exception& e) {
88656       {
88657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88658       };
88659     } catch (...) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88662       };
88663     }
88664   }
88665 }
88666
88667
88668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Empty(void * jarg1) {
88669   unsigned int jresult ;
88670   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88671   bool result;
88672
88673   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88674   {
88675     try {
88676       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *)arg1);
88677     } catch (std::out_of_range& e) {
88678       {
88679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88680       };
88681     } catch (std::exception& e) {
88682       {
88683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88684       };
88685     } catch (...) {
88686       {
88687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88688       };
88689     }
88690   }
88691   jresult = result;
88692   return jresult;
88693 }
88694
88695
88696 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_GetConnectionCount(void * jarg1) {
88697   unsigned long jresult ;
88698   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88699   std::size_t result;
88700
88701   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88702   {
88703     try {
88704       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *)arg1);
88705     } catch (std::out_of_range& e) {
88706       {
88707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88708       };
88709     } catch (std::exception& e) {
88710       {
88711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88712       };
88713     } catch (...) {
88714       {
88715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88716       };
88717     }
88718   }
88719   jresult = (unsigned long)result;
88720   return jresult;
88721 }
88722
88723
88724 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Connect(void * jarg1, void * jarg2) {
88725   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88726   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
88727
88728   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88729   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
88730   {
88731     try {
88732       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
88733     } catch (std::out_of_range& e) {
88734       {
88735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88736       };
88737     } catch (std::exception& e) {
88738       {
88739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88740       };
88741     } catch (...) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88744       };
88745     }
88746   }
88747 }
88748
88749
88750 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Disconnect(void * jarg1, void * jarg2) {
88751   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88752   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
88753
88754   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88755   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
88756   {
88757     try {
88758       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
88759     } catch (std::out_of_range& e) {
88760       {
88761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88762       };
88763     } catch (std::exception& e) {
88764       {
88765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88770       };
88771     }
88772   }
88773 }
88774
88775
88776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88777   unsigned int jresult ;
88778   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88779   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88780   Dali::TouchEvent *arg3 = 0 ;
88781   bool result;
88782
88783   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88784   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88785   if (!arg2) {
88786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88787     return 0;
88788   }
88789   arg3 = (Dali::TouchEvent *)jarg3;
88790   if (!arg3) {
88791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
88792     return 0;
88793   }
88794   {
88795     try {
88796       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,*arg2,(Dali::TouchEvent const &)*arg3);
88797     } catch (std::out_of_range& e) {
88798       {
88799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (std::exception& e) {
88802       {
88803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88804       };
88805     } catch (...) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88808       };
88809     }
88810   }
88811   jresult = result;
88812   return jresult;
88813 }
88814
88815
88816 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityActionScrollSignal() {
88817   void * jresult ;
88818   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *result = 0 ;
88819
88820   {
88821     try {
88822       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) >();
88823     } catch (std::out_of_range& e) {
88824       {
88825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88826       };
88827     } catch (std::exception& e) {
88828       {
88829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88830       };
88831     } catch (...) {
88832       {
88833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88834       };
88835     }
88836   }
88837   jresult = (void *)result;
88838   return jresult;
88839 }
88840
88841
88842 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityActionScrollSignal(void * jarg1) {
88843   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88844
88845   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88846   {
88847     try {
88848       delete arg1;
88849     } catch (std::out_of_range& e) {
88850       {
88851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88852       };
88853     } catch (std::exception& e) {
88854       {
88855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88856       };
88857     } catch (...) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88860       };
88861     }
88862   }
88863 }
88864
88865
88866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88867   unsigned int jresult ;
88868   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88869   bool result;
88870
88871   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88872   {
88873     try {
88874       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);
88875     } catch (std::out_of_range& e) {
88876       {
88877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88878       };
88879     } catch (std::exception& e) {
88880       {
88881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88882       };
88883     } catch (...) {
88884       {
88885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88886       };
88887     }
88888   }
88889   jresult = result;
88890   return jresult;
88891 }
88892
88893
88894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88895   unsigned long jresult ;
88896   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88897   std::size_t result;
88898
88899   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88900   {
88901     try {
88902       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);
88903     } catch (std::out_of_range& e) {
88904       {
88905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (std::exception& e) {
88908       {
88909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88910       };
88911     } catch (...) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88914       };
88915     }
88916   }
88917   jresult = (unsigned long)result;
88918   return jresult;
88919 }
88920
88921
88922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88923   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88924   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88925
88926   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88927   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88928   {
88929     try {
88930       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88931     } catch (std::out_of_range& e) {
88932       {
88933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88934       };
88935     } catch (std::exception& e) {
88936       {
88937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88938       };
88939     } catch (...) {
88940       {
88941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88942       };
88943     }
88944   }
88945 }
88946
88947
88948 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88949   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88950   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88951
88952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88953   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88954   {
88955     try {
88956       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88957     } catch (std::out_of_range& e) {
88958       {
88959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88960       };
88961     } catch (std::exception& e) {
88962       {
88963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88964       };
88965     } catch (...) {
88966       {
88967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88968       };
88969     }
88970   }
88971 }
88972
88973
88974 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88975   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88976   Dali::Actor arg2 ;
88977   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88978   Dali::Actor *argp2 ;
88979
88980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88981   argp2 = (Dali::Actor *)jarg2;
88982   if (!argp2) {
88983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88984     return ;
88985   }
88986   arg2 = *argp2;
88987   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88988   {
88989     try {
88990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88991     } catch (std::out_of_range& e) {
88992       {
88993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88994       };
88995     } catch (std::exception& e) {
88996       {
88997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88998       };
88999     } catch (...) {
89000       {
89001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89002       };
89003     }
89004   }
89005 }
89006
89007
89008 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityFocusOvershotSignal() {
89009   void * jresult ;
89010   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89011
89012   {
89013     try {
89014       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89015     } catch (std::out_of_range& e) {
89016       {
89017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89018       };
89019     } catch (std::exception& e) {
89020       {
89021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89022       };
89023     } catch (...) {
89024       {
89025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89026       };
89027     }
89028   }
89029   jresult = (void *)result;
89030   return jresult;
89031 }
89032
89033
89034 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89035   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89036
89037   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89038   {
89039     try {
89040       delete arg1;
89041     } catch (std::out_of_range& e) {
89042       {
89043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89044       };
89045     } catch (std::exception& e) {
89046       {
89047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89048       };
89049     } catch (...) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89052       };
89053     }
89054   }
89055 }
89056
89057
89058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Empty(void * jarg1) {
89059   unsigned int jresult ;
89060   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89061   bool result;
89062
89063   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89064   {
89065     try {
89066       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89067     } catch (std::out_of_range& e) {
89068       {
89069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89070       };
89071     } catch (std::exception& e) {
89072       {
89073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89074       };
89075     } catch (...) {
89076       {
89077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89078       };
89079     }
89080   }
89081   jresult = result;
89082   return jresult;
89083 }
89084
89085
89086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89087   unsigned long jresult ;
89088   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89089   std::size_t result;
89090
89091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89092   {
89093     try {
89094       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89095     } catch (std::out_of_range& e) {
89096       {
89097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (std::exception& e) {
89100       {
89101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (...) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89106       };
89107     }
89108   }
89109   jresult = (unsigned long)result;
89110   return jresult;
89111 }
89112
89113
89114 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89115   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89116   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89117
89118   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89119   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89120   {
89121     try {
89122       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89123     } catch (std::out_of_range& e) {
89124       {
89125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89126       };
89127     } catch (std::exception& e) {
89128       {
89129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89130       };
89131     } catch (...) {
89132       {
89133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89134       };
89135     }
89136   }
89137 }
89138
89139
89140 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89141   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89142   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89143
89144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89145   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89146   {
89147     try {
89148       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89149     } catch (std::out_of_range& e) {
89150       {
89151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89152       };
89153     } catch (std::exception& e) {
89154       {
89155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89156       };
89157     } catch (...) {
89158       {
89159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89160       };
89161     }
89162   }
89163 }
89164
89165
89166 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89167   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89168   Dali::Actor arg2 ;
89169   Dali::Actor arg3 ;
89170   Dali::Actor *argp2 ;
89171   Dali::Actor *argp3 ;
89172
89173   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89174   argp2 = (Dali::Actor *)jarg2;
89175   if (!argp2) {
89176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89177     return ;
89178   }
89179   arg2 = *argp2;
89180   argp3 = (Dali::Actor *)jarg3;
89181   if (!argp3) {
89182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89183     return ;
89184   }
89185   arg3 = *argp3;
89186   {
89187     try {
89188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89189     } catch (std::out_of_range& e) {
89190       {
89191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89192       };
89193     } catch (std::exception& e) {
89194       {
89195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89196       };
89197     } catch (...) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89200       };
89201     }
89202   }
89203 }
89204
89205
89206 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FocusChangedSignal() {
89207   void * jresult ;
89208   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89209
89210   {
89211     try {
89212       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89213     } catch (std::out_of_range& e) {
89214       {
89215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89216       };
89217     } catch (std::exception& e) {
89218       {
89219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89220       };
89221     } catch (...) {
89222       {
89223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89224       };
89225     }
89226   }
89227   jresult = (void *)result;
89228   return jresult;
89229 }
89230
89231
89232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FocusChangedSignal(void * jarg1) {
89233   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89234
89235   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89236   {
89237     try {
89238       delete arg1;
89239     } catch (std::out_of_range& e) {
89240       {
89241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89242       };
89243     } catch (std::exception& e) {
89244       {
89245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89246       };
89247     } catch (...) {
89248       {
89249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89250       };
89251     }
89252   }
89253 }
89254
89255
89256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Empty(void * jarg1) {
89257   unsigned int jresult ;
89258   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89259   bool result;
89260
89261   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89262   {
89263     try {
89264       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89265     } catch (std::out_of_range& e) {
89266       {
89267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89268       };
89269     } catch (std::exception& e) {
89270       {
89271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89276       };
89277     }
89278   }
89279   jresult = result;
89280   return jresult;
89281 }
89282
89283
89284 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89285   unsigned long jresult ;
89286   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89287   std::size_t result;
89288
89289   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89290   {
89291     try {
89292       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89293     } catch (std::out_of_range& e) {
89294       {
89295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89296       };
89297     } catch (std::exception& e) {
89298       {
89299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89300       };
89301     } catch (...) {
89302       {
89303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89304       };
89305     }
89306   }
89307   jresult = (unsigned long)result;
89308   return jresult;
89309 }
89310
89311
89312 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89313   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89314   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89315
89316   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89317   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89318   {
89319     try {
89320       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89321     } catch (std::out_of_range& e) {
89322       {
89323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89324       };
89325     } catch (std::exception& e) {
89326       {
89327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89328       };
89329     } catch (...) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89332       };
89333     }
89334   }
89335 }
89336
89337
89338 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89339   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89340   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89341
89342   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89343   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89344   {
89345     try {
89346       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89347     } catch (std::out_of_range& e) {
89348       {
89349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89350       };
89351     } catch (std::exception& e) {
89352       {
89353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89354       };
89355     } catch (...) {
89356       {
89357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89358       };
89359     }
89360   }
89361 }
89362
89363
89364 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89365   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89366   Dali::Actor arg2 ;
89367   bool arg3 ;
89368   Dali::Actor *argp2 ;
89369
89370   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89371   argp2 = (Dali::Actor *)jarg2;
89372   if (!argp2) {
89373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89374     return ;
89375   }
89376   arg2 = *argp2;
89377   arg3 = jarg3 ? true : false;
89378   {
89379     try {
89380       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89381     } catch (std::out_of_range& e) {
89382       {
89383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89384       };
89385     } catch (std::exception& e) {
89386       {
89387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89388       };
89389     } catch (...) {
89390       {
89391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89392       };
89393     }
89394   }
89395 }
89396
89397
89398 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FocusGroupChangedSignal() {
89399   void * jresult ;
89400   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89401
89402   {
89403     try {
89404       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89405     } catch (std::out_of_range& e) {
89406       {
89407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89408       };
89409     } catch (std::exception& e) {
89410       {
89411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89412       };
89413     } catch (...) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89416       };
89417     }
89418   }
89419   jresult = (void *)result;
89420   return jresult;
89421 }
89422
89423
89424 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FocusGroupChangedSignal(void * jarg1) {
89425   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89426
89427   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89428   {
89429     try {
89430       delete arg1;
89431     } catch (std::out_of_range& e) {
89432       {
89433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89434       };
89435     } catch (std::exception& e) {
89436       {
89437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89438       };
89439     } catch (...) {
89440       {
89441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89442       };
89443     }
89444   }
89445 }
89446
89447
89448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Empty(void * jarg1) {
89449   unsigned int jresult ;
89450   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89451   bool result;
89452
89453   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89454   {
89455     try {
89456       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);
89457     } catch (std::out_of_range& e) {
89458       {
89459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89460       };
89461     } catch (std::exception& e) {
89462       {
89463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89464       };
89465     } catch (...) {
89466       {
89467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89468       };
89469     }
89470   }
89471   jresult = result;
89472   return jresult;
89473 }
89474
89475
89476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89477   unsigned long jresult ;
89478   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89479   std::size_t result;
89480
89481   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89482   {
89483     try {
89484       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);
89485     } catch (std::out_of_range& e) {
89486       {
89487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89488       };
89489     } catch (std::exception& e) {
89490       {
89491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89492       };
89493     } catch (...) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89496       };
89497     }
89498   }
89499   jresult = (unsigned long)result;
89500   return jresult;
89501 }
89502
89503
89504 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89505   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89506   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89507
89508   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89509   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89510   {
89511     try {
89512       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89513     } catch (std::out_of_range& e) {
89514       {
89515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89516       };
89517     } catch (std::exception& e) {
89518       {
89519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89520       };
89521     } catch (...) {
89522       {
89523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89524       };
89525     }
89526   }
89527 }
89528
89529
89530 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89531   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89532   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89533
89534   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89535   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89536   {
89537     try {
89538       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89539     } catch (std::out_of_range& e) {
89540       {
89541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89542       };
89543     } catch (std::exception& e) {
89544       {
89545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89546       };
89547     } catch (...) {
89548       {
89549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89550       };
89551     }
89552   }
89553 }
89554
89555
89556 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89557   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89558   Dali::Toolkit::StyleManager arg2 ;
89559   Dali::StyleChange::Type arg3 ;
89560   Dali::Toolkit::StyleManager *argp2 ;
89561
89562   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89563   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89564   if (!argp2) {
89565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89566     return ;
89567   }
89568   arg2 = *argp2;
89569   arg3 = (Dali::StyleChange::Type)jarg3;
89570   {
89571     try {
89572       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89573     } catch (std::out_of_range& e) {
89574       {
89575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89576       };
89577     } catch (std::exception& e) {
89578       {
89579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89580       };
89581     } catch (...) {
89582       {
89583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89584       };
89585     }
89586   }
89587 }
89588
89589
89590 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StyleChangedSignal() {
89591   void * jresult ;
89592   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89593
89594   {
89595     try {
89596       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89597     } catch (std::out_of_range& e) {
89598       {
89599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89600       };
89601     } catch (std::exception& e) {
89602       {
89603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89604       };
89605     } catch (...) {
89606       {
89607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89608       };
89609     }
89610   }
89611   jresult = (void *)result;
89612   return jresult;
89613 }
89614
89615
89616 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StyleChangedSignal(void * jarg1) {
89617   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89618
89619   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89620   {
89621     try {
89622       delete arg1;
89623     } catch (std::out_of_range& e) {
89624       {
89625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89626       };
89627     } catch (std::exception& e) {
89628       {
89629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89630       };
89631     } catch (...) {
89632       {
89633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89634       };
89635     }
89636   }
89637 }
89638
89639
89640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ButtonSignal_Empty(void * jarg1) {
89641   unsigned int jresult ;
89642   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89643   bool result;
89644
89645   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89646   {
89647     try {
89648       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89649     } catch (std::out_of_range& e) {
89650       {
89651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89652       };
89653     } catch (std::exception& e) {
89654       {
89655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89656       };
89657     } catch (...) {
89658       {
89659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89660       };
89661     }
89662   }
89663   jresult = result;
89664   return jresult;
89665 }
89666
89667
89668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ButtonSignal_GetConnectionCount(void * jarg1) {
89669   unsigned long jresult ;
89670   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89671   std::size_t result;
89672
89673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89674   {
89675     try {
89676       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89677     } catch (std::out_of_range& e) {
89678       {
89679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89680       };
89681     } catch (std::exception& e) {
89682       {
89683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89684       };
89685     } catch (...) {
89686       {
89687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89688       };
89689     }
89690   }
89691   jresult = (unsigned long)result;
89692   return jresult;
89693 }
89694
89695
89696 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89697   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89698   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89699
89700   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89701   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89702   {
89703     try {
89704       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89705     } catch (std::out_of_range& e) {
89706       {
89707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89708       };
89709     } catch (std::exception& e) {
89710       {
89711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89712       };
89713     } catch (...) {
89714       {
89715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89716       };
89717     }
89718   }
89719 }
89720
89721
89722 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89723   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89724   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89725
89726   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89727   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89728   {
89729     try {
89730       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89731     } catch (std::out_of_range& e) {
89732       {
89733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89734       };
89735     } catch (std::exception& e) {
89736       {
89737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89738       };
89739     } catch (...) {
89740       {
89741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89742       };
89743     }
89744   }
89745 }
89746
89747
89748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89749   unsigned int jresult ;
89750   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89751   Dali::Toolkit::Button arg2 ;
89752   Dali::Toolkit::Button *argp2 ;
89753   bool result;
89754
89755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89756   argp2 = (Dali::Toolkit::Button *)jarg2;
89757   if (!argp2) {
89758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89759     return 0;
89760   }
89761   arg2 = *argp2;
89762   {
89763     try {
89764       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89765     } catch (std::out_of_range& e) {
89766       {
89767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89768       };
89769     } catch (std::exception& e) {
89770       {
89771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89772       };
89773     } catch (...) {
89774       {
89775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89776       };
89777     }
89778   }
89779   jresult = result;
89780   return jresult;
89781 }
89782
89783
89784 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ButtonSignal() {
89785   void * jresult ;
89786   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89787
89788   {
89789     try {
89790       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89791     } catch (std::out_of_range& e) {
89792       {
89793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89794       };
89795     } catch (std::exception& e) {
89796       {
89797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89798       };
89799     } catch (...) {
89800       {
89801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89802       };
89803     }
89804   }
89805   jresult = (void *)result;
89806   return jresult;
89807 }
89808
89809
89810 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ButtonSignal(void * jarg1) {
89811   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89812
89813   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89814   {
89815     try {
89816       delete arg1;
89817     } catch (std::out_of_range& e) {
89818       {
89819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89820       };
89821     } catch (std::exception& e) {
89822       {
89823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89824       };
89825     } catch (...) {
89826       {
89827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89828       };
89829     }
89830   }
89831 }
89832
89833
89834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Empty(void * jarg1) {
89835   unsigned int jresult ;
89836   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89837   bool result;
89838
89839   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89840   {
89841     try {
89842       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89843     } catch (std::out_of_range& e) {
89844       {
89845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89846       };
89847     } catch (std::exception& e) {
89848       {
89849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89850       };
89851     } catch (...) {
89852       {
89853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89854       };
89855     }
89856   }
89857   jresult = result;
89858   return jresult;
89859 }
89860
89861
89862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89863   unsigned long jresult ;
89864   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89865   std::size_t result;
89866
89867   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89868   {
89869     try {
89870       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89871     } catch (std::out_of_range& e) {
89872       {
89873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89874       };
89875     } catch (std::exception& e) {
89876       {
89877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89878       };
89879     } catch (...) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89882       };
89883     }
89884   }
89885   jresult = (unsigned long)result;
89886   return jresult;
89887 }
89888
89889
89890 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89891   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89892   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89893
89894   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89895   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89896   {
89897     try {
89898       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89899     } catch (std::out_of_range& e) {
89900       {
89901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89902       };
89903     } catch (std::exception& e) {
89904       {
89905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89906       };
89907     } catch (...) {
89908       {
89909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89910       };
89911     }
89912   }
89913 }
89914
89915
89916 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89917   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89918   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89919
89920   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89921   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89922   {
89923     try {
89924       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89925     } catch (std::out_of_range& e) {
89926       {
89927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89928       };
89929     } catch (std::exception& e) {
89930       {
89931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89932       };
89933     } catch (...) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89936       };
89937     }
89938   }
89939 }
89940
89941
89942 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89943   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89944   Dali::Toolkit::GaussianBlurView arg2 ;
89945   Dali::Toolkit::GaussianBlurView *argp2 ;
89946
89947   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89948   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89949   if (!argp2) {
89950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89951     return ;
89952   }
89953   arg2 = *argp2;
89954   {
89955     try {
89956       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89957     } catch (std::out_of_range& e) {
89958       {
89959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89960       };
89961     } catch (std::exception& e) {
89962       {
89963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89964       };
89965     } catch (...) {
89966       {
89967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89968       };
89969     }
89970   }
89971 }
89972
89973
89974 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurViewSignal() {
89975   void * jresult ;
89976   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89977
89978   {
89979     try {
89980       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89981     } catch (std::out_of_range& e) {
89982       {
89983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89984       };
89985     } catch (std::exception& e) {
89986       {
89987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89988       };
89989     } catch (...) {
89990       {
89991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89992       };
89993     }
89994   }
89995   jresult = (void *)result;
89996   return jresult;
89997 }
89998
89999
90000 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GaussianBlurViewSignal(void * jarg1) {
90001   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90002
90003   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90004   {
90005     try {
90006       delete arg1;
90007     } catch (std::out_of_range& e) {
90008       {
90009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (std::exception& e) {
90012       {
90013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (...) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90018       };
90019     }
90020   }
90021 }
90022
90023
90024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PageTurnSignal_Empty(void * jarg1) {
90025   unsigned int jresult ;
90026   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90027   bool result;
90028
90029   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90030   {
90031     try {
90032       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);
90033     } catch (std::out_of_range& e) {
90034       {
90035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90036       };
90037     } catch (std::exception& e) {
90038       {
90039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90040       };
90041     } catch (...) {
90042       {
90043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90044       };
90045     }
90046   }
90047   jresult = result;
90048   return jresult;
90049 }
90050
90051
90052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PageTurnSignal_GetConnectionCount(void * jarg1) {
90053   unsigned long jresult ;
90054   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90055   std::size_t result;
90056
90057   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90058   {
90059     try {
90060       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);
90061     } catch (std::out_of_range& e) {
90062       {
90063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90064       };
90065     } catch (std::exception& e) {
90066       {
90067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90068       };
90069     } catch (...) {
90070       {
90071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90072       };
90073     }
90074   }
90075   jresult = (unsigned long)result;
90076   return jresult;
90077 }
90078
90079
90080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90081   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90082   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90083
90084   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90085   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90086   {
90087     try {
90088       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90089     } catch (std::out_of_range& e) {
90090       {
90091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90092       };
90093     } catch (std::exception& e) {
90094       {
90095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90096       };
90097     } catch (...) {
90098       {
90099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90100       };
90101     }
90102   }
90103 }
90104
90105
90106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90107   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90108   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90109
90110   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90111   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90112   {
90113     try {
90114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90115     } catch (std::out_of_range& e) {
90116       {
90117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90118       };
90119     } catch (std::exception& e) {
90120       {
90121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90122       };
90123     } catch (...) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90126       };
90127     }
90128   }
90129 }
90130
90131
90132 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90133   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90134   Dali::Toolkit::PageTurnView arg2 ;
90135   unsigned int arg3 ;
90136   bool arg4 ;
90137   Dali::Toolkit::PageTurnView *argp2 ;
90138
90139   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90140   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90141   if (!argp2) {
90142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90143     return ;
90144   }
90145   arg2 = *argp2;
90146   arg3 = (unsigned int)jarg3;
90147   arg4 = jarg4 ? true : false;
90148   {
90149     try {
90150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90151     } catch (std::out_of_range& e) {
90152       {
90153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90154       };
90155     } catch (std::exception& e) {
90156       {
90157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90158       };
90159     } catch (...) {
90160       {
90161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90162       };
90163     }
90164   }
90165 }
90166
90167
90168 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnSignal() {
90169   void * jresult ;
90170   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90171
90172   {
90173     try {
90174       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90175     } catch (std::out_of_range& e) {
90176       {
90177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90178       };
90179     } catch (std::exception& e) {
90180       {
90181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90182       };
90183     } catch (...) {
90184       {
90185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90186       };
90187     }
90188   }
90189   jresult = (void *)result;
90190   return jresult;
90191 }
90192
90193
90194 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnSignal(void * jarg1) {
90195   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90196
90197   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90198   {
90199     try {
90200       delete arg1;
90201     } catch (std::out_of_range& e) {
90202       {
90203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90204       };
90205     } catch (std::exception& e) {
90206       {
90207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90208       };
90209     } catch (...) {
90210       {
90211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90212       };
90213     }
90214   }
90215 }
90216
90217
90218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PagePanSignal_Empty(void * jarg1) {
90219   unsigned int jresult ;
90220   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90221   bool result;
90222
90223   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90224   {
90225     try {
90226       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90227     } catch (std::out_of_range& e) {
90228       {
90229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90230       };
90231     } catch (std::exception& e) {
90232       {
90233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90234       };
90235     } catch (...) {
90236       {
90237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90238       };
90239     }
90240   }
90241   jresult = result;
90242   return jresult;
90243 }
90244
90245
90246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PagePanSignal_GetConnectionCount(void * jarg1) {
90247   unsigned long jresult ;
90248   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90249   std::size_t result;
90250
90251   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90252   {
90253     try {
90254       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90255     } catch (std::out_of_range& e) {
90256       {
90257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90258       };
90259     } catch (std::exception& e) {
90260       {
90261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90262       };
90263     } catch (...) {
90264       {
90265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90266       };
90267     }
90268   }
90269   jresult = (unsigned long)result;
90270   return jresult;
90271 }
90272
90273
90274 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90275   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90276   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90277
90278   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90279   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90280   {
90281     try {
90282       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90283     } catch (std::out_of_range& e) {
90284       {
90285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90286       };
90287     } catch (std::exception& e) {
90288       {
90289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90290       };
90291     } catch (...) {
90292       {
90293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90294       };
90295     }
90296   }
90297 }
90298
90299
90300 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90301   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90302   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90303
90304   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90305   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90306   {
90307     try {
90308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90309     } catch (std::out_of_range& e) {
90310       {
90311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90312       };
90313     } catch (std::exception& e) {
90314       {
90315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90316       };
90317     } catch (...) {
90318       {
90319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90320       };
90321     }
90322   }
90323 }
90324
90325
90326 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90327   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90328   Dali::Toolkit::PageTurnView arg2 ;
90329   Dali::Toolkit::PageTurnView *argp2 ;
90330
90331   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90332   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90333   if (!argp2) {
90334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90335     return ;
90336   }
90337   arg2 = *argp2;
90338   {
90339     try {
90340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90341     } catch (std::out_of_range& e) {
90342       {
90343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90344       };
90345     } catch (std::exception& e) {
90346       {
90347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90348       };
90349     } catch (...) {
90350       {
90351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90352       };
90353     }
90354   }
90355 }
90356
90357
90358 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PagePanSignal() {
90359   void * jresult ;
90360   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90361
90362   {
90363     try {
90364       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90365     } catch (std::out_of_range& e) {
90366       {
90367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90368       };
90369     } catch (std::exception& e) {
90370       {
90371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90372       };
90373     } catch (...) {
90374       {
90375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90376       };
90377     }
90378   }
90379   jresult = (void *)result;
90380   return jresult;
90381 }
90382
90383
90384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PagePanSignal(void * jarg1) {
90385   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90386
90387   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90388   {
90389     try {
90390       delete arg1;
90391     } catch (std::out_of_range& e) {
90392       {
90393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90394       };
90395     } catch (std::exception& e) {
90396       {
90397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90398       };
90399     } catch (...) {
90400       {
90401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90402       };
90403     }
90404   }
90405 }
90406
90407
90408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90409   unsigned int jresult ;
90410   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90411   bool result;
90412
90413   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90414   {
90415     try {
90416       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);
90417     } catch (std::out_of_range& e) {
90418       {
90419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90420       };
90421     } catch (std::exception& e) {
90422       {
90423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90424       };
90425     } catch (...) {
90426       {
90427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90428       };
90429     }
90430   }
90431   jresult = result;
90432   return jresult;
90433 }
90434
90435
90436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90437   unsigned long jresult ;
90438   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90439   std::size_t result;
90440
90441   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90442   {
90443     try {
90444       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);
90445     } catch (std::out_of_range& e) {
90446       {
90447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90448       };
90449     } catch (std::exception& e) {
90450       {
90451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (...) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90456       };
90457     }
90458   }
90459   jresult = (unsigned long)result;
90460   return jresult;
90461 }
90462
90463
90464 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90465   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90466   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90467
90468   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90469   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90470   {
90471     try {
90472       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90473     } catch (std::out_of_range& e) {
90474       {
90475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90476       };
90477     } catch (std::exception& e) {
90478       {
90479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90480       };
90481     } catch (...) {
90482       {
90483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90484       };
90485     }
90486   }
90487 }
90488
90489
90490 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90491   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90492   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90493
90494   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90495   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90496   {
90497     try {
90498       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90499     } catch (std::out_of_range& e) {
90500       {
90501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90502       };
90503     } catch (std::exception& e) {
90504       {
90505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90506       };
90507     } catch (...) {
90508       {
90509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90510       };
90511     }
90512   }
90513 }
90514
90515
90516 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90517   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90518   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90519
90520   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90521   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90522   if (!arg2) {
90523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90524     return ;
90525   }
90526   {
90527     try {
90528       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90529     } catch (std::out_of_range& e) {
90530       {
90531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90532       };
90533     } catch (std::exception& e) {
90534       {
90535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90536       };
90537     } catch (...) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90540       };
90541     }
90542   }
90543 }
90544
90545
90546 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewSnapStartedSignal() {
90547   void * jresult ;
90548   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90549
90550   {
90551     try {
90552       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90553     } catch (std::out_of_range& e) {
90554       {
90555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90556       };
90557     } catch (std::exception& e) {
90558       {
90559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90560       };
90561     } catch (...) {
90562       {
90563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90564       };
90565     }
90566   }
90567   jresult = (void *)result;
90568   return jresult;
90569 }
90570
90571
90572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90573   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90574
90575   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90576   {
90577     try {
90578       delete arg1;
90579     } catch (std::out_of_range& e) {
90580       {
90581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90582       };
90583     } catch (std::exception& e) {
90584       {
90585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90590       };
90591     }
90592   }
90593 }
90594
90595
90596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollableSignal_Empty(void * jarg1) {
90597   unsigned int jresult ;
90598   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90599   bool result;
90600
90601   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90602   {
90603     try {
90604       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90612       };
90613     } catch (...) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90616       };
90617     }
90618   }
90619   jresult = result;
90620   return jresult;
90621 }
90622
90623
90624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ScrollableSignal_GetConnectionCount(void * jarg1) {
90625   unsigned long jresult ;
90626   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90627   std::size_t result;
90628
90629   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90630   {
90631     try {
90632       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90633     } catch (std::out_of_range& e) {
90634       {
90635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90636       };
90637     } catch (std::exception& e) {
90638       {
90639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90640       };
90641     } catch (...) {
90642       {
90643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90644       };
90645     }
90646   }
90647   jresult = (unsigned long)result;
90648   return jresult;
90649 }
90650
90651
90652 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90653   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90654   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90655
90656   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90657   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90658   {
90659     try {
90660       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90661     } catch (std::out_of_range& e) {
90662       {
90663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90664       };
90665     } catch (std::exception& e) {
90666       {
90667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90668       };
90669     } catch (...) {
90670       {
90671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90672       };
90673     }
90674   }
90675 }
90676
90677
90678 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90679   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90680   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90681
90682   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90683   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90684   {
90685     try {
90686       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90687     } catch (std::out_of_range& e) {
90688       {
90689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90690       };
90691     } catch (std::exception& e) {
90692       {
90693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90694       };
90695     } catch (...) {
90696       {
90697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90698       };
90699     }
90700   }
90701 }
90702
90703
90704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90705   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90706   Dali::Vector2 *arg2 = 0 ;
90707
90708   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90709   arg2 = (Dali::Vector2 *)jarg2;
90710   if (!arg2) {
90711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90712     return ;
90713   }
90714   {
90715     try {
90716       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90717     } catch (std::out_of_range& e) {
90718       {
90719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90720       };
90721     } catch (std::exception& e) {
90722       {
90723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90724       };
90725     } catch (...) {
90726       {
90727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90728       };
90729     }
90730   }
90731 }
90732
90733
90734 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollableSignal() {
90735   void * jresult ;
90736   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90737
90738   {
90739     try {
90740       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90741     } catch (std::out_of_range& e) {
90742       {
90743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90744       };
90745     } catch (std::exception& e) {
90746       {
90747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90748       };
90749     } catch (...) {
90750       {
90751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90752       };
90753     }
90754   }
90755   jresult = (void *)result;
90756   return jresult;
90757 }
90758
90759
90760 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollableSignal(void * jarg1) {
90761   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90762
90763   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90764   {
90765     try {
90766       delete arg1;
90767     } catch (std::out_of_range& e) {
90768       {
90769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90770       };
90771     } catch (std::exception& e) {
90772       {
90773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90774       };
90775     } catch (...) {
90776       {
90777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90778       };
90779     }
90780   }
90781 }
90782
90783
90784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TextEditorSignal_Empty(void * jarg1) {
90785   unsigned int jresult ;
90786   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90787   bool result;
90788
90789   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90790   {
90791     try {
90792       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90793     } catch (std::out_of_range& e) {
90794       {
90795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90796       };
90797     } catch (std::exception& e) {
90798       {
90799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90800       };
90801     } catch (...) {
90802       {
90803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90804       };
90805     }
90806   }
90807   jresult = result;
90808   return jresult;
90809 }
90810
90811
90812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextEditorSignal_GetConnectionCount(void * jarg1) {
90813   unsigned long jresult ;
90814   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90815   std::size_t result;
90816
90817   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90818   {
90819     try {
90820       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90821     } catch (std::out_of_range& e) {
90822       {
90823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90824       };
90825     } catch (std::exception& e) {
90826       {
90827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90828       };
90829     } catch (...) {
90830       {
90831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90832       };
90833     }
90834   }
90835   jresult = (unsigned long)result;
90836   return jresult;
90837 }
90838
90839
90840 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90841   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90842   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90843
90844   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90845   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90846   {
90847     try {
90848       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90849     } catch (std::out_of_range& e) {
90850       {
90851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90852       };
90853     } catch (std::exception& e) {
90854       {
90855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90856       };
90857     } catch (...) {
90858       {
90859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90860       };
90861     }
90862   }
90863 }
90864
90865
90866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90867   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90868   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90869
90870   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90871   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90872   {
90873     try {
90874       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90875     } catch (std::out_of_range& e) {
90876       {
90877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90878       };
90879     } catch (std::exception& e) {
90880       {
90881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90882       };
90883     } catch (...) {
90884       {
90885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90886       };
90887     }
90888   }
90889 }
90890
90891
90892 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90893   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90894   Dali::Toolkit::TextEditor arg2 ;
90895   Dali::Toolkit::TextEditor *argp2 ;
90896
90897   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90898   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90899   if (!argp2) {
90900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90901     return ;
90902   }
90903   arg2 = *argp2;
90904   {
90905     try {
90906       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90907     } catch (std::out_of_range& e) {
90908       {
90909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90910       };
90911     } catch (std::exception& e) {
90912       {
90913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90914       };
90915     } catch (...) {
90916       {
90917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90918       };
90919     }
90920   }
90921 }
90922
90923
90924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditorSignal() {
90925   void * jresult ;
90926   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90927
90928   {
90929     try {
90930       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90931     } catch (std::out_of_range& e) {
90932       {
90933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90934       };
90935     } catch (std::exception& e) {
90936       {
90937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90938       };
90939     } catch (...) {
90940       {
90941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90942       };
90943     }
90944   }
90945   jresult = (void *)result;
90946   return jresult;
90947 }
90948
90949
90950 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditorSignal(void * jarg1) {
90951   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90952
90953   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90954   {
90955     try {
90956       delete arg1;
90957     } catch (std::out_of_range& e) {
90958       {
90959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90960       };
90961     } catch (std::exception& e) {
90962       {
90963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90964       };
90965     } catch (...) {
90966       {
90967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90968       };
90969     }
90970   }
90971 }
90972
90973
90974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TextFieldSignal_Empty(void * jarg1) {
90975   unsigned int jresult ;
90976   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90977   bool result;
90978
90979   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90980   {
90981     try {
90982       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90983     } catch (std::out_of_range& e) {
90984       {
90985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90986       };
90987     } catch (std::exception& e) {
90988       {
90989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90990       };
90991     } catch (...) {
90992       {
90993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90994       };
90995     }
90996   }
90997   jresult = result;
90998   return jresult;
90999 }
91000
91001
91002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextFieldSignal_GetConnectionCount(void * jarg1) {
91003   unsigned long jresult ;
91004   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91005   std::size_t result;
91006
91007   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91008   {
91009     try {
91010       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91011     } catch (std::out_of_range& e) {
91012       {
91013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91014       };
91015     } catch (std::exception& e) {
91016       {
91017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91018       };
91019     } catch (...) {
91020       {
91021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91022       };
91023     }
91024   }
91025   jresult = (unsigned long)result;
91026   return jresult;
91027 }
91028
91029
91030 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91031   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91032   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91033
91034   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91035   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91036   {
91037     try {
91038       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91039     } catch (std::out_of_range& e) {
91040       {
91041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91042       };
91043     } catch (std::exception& e) {
91044       {
91045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91050       };
91051     }
91052   }
91053 }
91054
91055
91056 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91057   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91058   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91059
91060   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91061   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91062   {
91063     try {
91064       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91065     } catch (std::out_of_range& e) {
91066       {
91067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91068       };
91069     } catch (std::exception& e) {
91070       {
91071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91072       };
91073     } catch (...) {
91074       {
91075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91076       };
91077     }
91078   }
91079 }
91080
91081
91082 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91083   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91084   Dali::Toolkit::TextField arg2 ;
91085   Dali::Toolkit::TextField *argp2 ;
91086
91087   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91088   argp2 = (Dali::Toolkit::TextField *)jarg2;
91089   if (!argp2) {
91090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91091     return ;
91092   }
91093   arg2 = *argp2;
91094   {
91095     try {
91096       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91097     } catch (std::out_of_range& e) {
91098       {
91099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91100       };
91101     } catch (std::exception& e) {
91102       {
91103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91104       };
91105     } catch (...) {
91106       {
91107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91108       };
91109     }
91110   }
91111 }
91112
91113
91114 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextFieldSignal() {
91115   void * jresult ;
91116   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91117
91118   {
91119     try {
91120       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91121     } catch (std::out_of_range& e) {
91122       {
91123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91124       };
91125     } catch (std::exception& e) {
91126       {
91127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91128       };
91129     } catch (...) {
91130       {
91131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91132       };
91133     }
91134   }
91135   jresult = (void *)result;
91136   return jresult;
91137 }
91138
91139
91140 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextFieldSignal(void * jarg1) {
91141   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91142
91143   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91144   {
91145     try {
91146       delete arg1;
91147     } catch (std::out_of_range& e) {
91148       {
91149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91150       };
91151     } catch (std::exception& e) {
91152       {
91153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91154       };
91155     } catch (...) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91158       };
91159     }
91160   }
91161 }
91162
91163
91164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Empty(void * jarg1) {
91165   unsigned int jresult ;
91166   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91167   bool result;
91168
91169   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91170   {
91171     try {
91172       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);
91173     } catch (std::out_of_range& e) {
91174       {
91175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91176       };
91177     } catch (std::exception& e) {
91178       {
91179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91180       };
91181     } catch (...) {
91182       {
91183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91184       };
91185     }
91186   }
91187   jresult = result;
91188   return jresult;
91189 }
91190
91191
91192 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_GetConnectionCount(void * jarg1) {
91193   unsigned long jresult ;
91194   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91195   std::size_t result;
91196
91197   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91198   {
91199     try {
91200       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);
91201     } catch (std::out_of_range& e) {
91202       {
91203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91204       };
91205     } catch (std::exception& e) {
91206       {
91207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91208       };
91209     } catch (...) {
91210       {
91211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91212       };
91213     }
91214   }
91215   jresult = (unsigned long)result;
91216   return jresult;
91217 }
91218
91219
91220 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Connect(void * jarg1, void * jarg2) {
91221   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91222   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91223
91224   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91225   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91226   {
91227     try {
91228       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91236       };
91237     } catch (...) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91240       };
91241     }
91242   }
91243 }
91244
91245
91246 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
91247   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91248   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91249
91250   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91251   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91252   {
91253     try {
91254       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91255     } catch (std::out_of_range& e) {
91256       {
91257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91258       };
91259     } catch (std::exception& e) {
91260       {
91261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91262       };
91263     } catch (...) {
91264       {
91265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91266       };
91267     }
91268   }
91269 }
91270
91271
91272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91273   unsigned int jresult ;
91274   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91275   Dali::Toolkit::Control arg2 ;
91276   Dali::KeyEvent *arg3 = 0 ;
91277   Dali::Toolkit::Control *argp2 ;
91278   bool result;
91279
91280   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91281   argp2 = (Dali::Toolkit::Control *)jarg2;
91282   if (!argp2) {
91283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91284     return 0;
91285   }
91286   arg2 = *argp2;
91287   arg3 = (Dali::KeyEvent *)jarg3;
91288   if (!arg3) {
91289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91290     return 0;
91291   }
91292   {
91293     try {
91294       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);
91295     } catch (std::out_of_range& e) {
91296       {
91297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91298       };
91299     } catch (std::exception& e) {
91300       {
91301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91302       };
91303     } catch (...) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91306       };
91307     }
91308   }
91309   jresult = result;
91310   return jresult;
91311 }
91312
91313
91314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ControlKeyEventSignal() {
91315   void * jresult ;
91316   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91317
91318   {
91319     try {
91320       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91321     } catch (std::out_of_range& e) {
91322       {
91323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (std::exception& e) {
91326       {
91327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91328       };
91329     } catch (...) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91332       };
91333     }
91334   }
91335   jresult = (void *)result;
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ControlKeyEventSignal(void * jarg1) {
91341   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91342
91343   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91344   {
91345     try {
91346       delete arg1;
91347     } catch (std::out_of_range& e) {
91348       {
91349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91350       };
91351     } catch (std::exception& e) {
91352       {
91353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91354       };
91355     } catch (...) {
91356       {
91357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91358       };
91359     }
91360   }
91361 }
91362
91363
91364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Empty(void * jarg1) {
91365   unsigned int jresult ;
91366   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91367   bool result;
91368
91369   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91370   {
91371     try {
91372       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91373     } catch (std::out_of_range& e) {
91374       {
91375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91376       };
91377     } catch (std::exception& e) {
91378       {
91379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91380       };
91381     } catch (...) {
91382       {
91383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91384       };
91385     }
91386   }
91387   jresult = result;
91388   return jresult;
91389 }
91390
91391
91392 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91393   unsigned long jresult ;
91394   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91395   std::size_t result;
91396
91397   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91398   {
91399     try {
91400       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91401     } catch (std::out_of_range& e) {
91402       {
91403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91404       };
91405     } catch (std::exception& e) {
91406       {
91407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91408       };
91409     } catch (...) {
91410       {
91411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91412       };
91413     }
91414   }
91415   jresult = (unsigned long)result;
91416   return jresult;
91417 }
91418
91419
91420 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91421   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91422   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91423
91424   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91425   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91426   {
91427     try {
91428       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91429     } catch (std::out_of_range& e) {
91430       {
91431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (std::exception& e) {
91434       {
91435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91436       };
91437     } catch (...) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91440       };
91441     }
91442   }
91443 }
91444
91445
91446 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91447   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91448   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91449
91450   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91451   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91452   {
91453     try {
91454       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91455     } catch (std::out_of_range& e) {
91456       {
91457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91458       };
91459     } catch (std::exception& e) {
91460       {
91461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91466       };
91467     }
91468   }
91469 }
91470
91471
91472 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91473   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91474   Dali::Toolkit::Control arg2 ;
91475   Dali::Toolkit::Control *argp2 ;
91476
91477   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91478   argp2 = (Dali::Toolkit::Control *)jarg2;
91479   if (!argp2) {
91480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91481     return ;
91482   }
91483   arg2 = *argp2;
91484   {
91485     try {
91486       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91487     } catch (std::out_of_range& e) {
91488       {
91489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91490       };
91491     } catch (std::exception& e) {
91492       {
91493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91498       };
91499     }
91500   }
91501 }
91502
91503
91504 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyInputFocusSignal() {
91505   void * jresult ;
91506   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91507
91508   {
91509     try {
91510       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91511     } catch (std::out_of_range& e) {
91512       {
91513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91514       };
91515     } catch (std::exception& e) {
91516       {
91517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91518       };
91519     } catch (...) {
91520       {
91521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91522       };
91523     }
91524   }
91525   jresult = (void *)result;
91526   return jresult;
91527 }
91528
91529
91530 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyInputFocusSignal(void * jarg1) {
91531   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91532
91533   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91534   {
91535     try {
91536       delete arg1;
91537     } catch (std::out_of_range& e) {
91538       {
91539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91540       };
91541     } catch (std::exception& e) {
91542       {
91543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91544       };
91545     } catch (...) {
91546       {
91547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91548       };
91549     }
91550   }
91551 }
91552
91553
91554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VideoViewSignal_Empty(void * jarg1) {
91555   unsigned int jresult ;
91556   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91557   bool result;
91558
91559   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91560   {
91561     try {
91562       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91563     } catch (std::out_of_range& e) {
91564       {
91565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91566       };
91567     } catch (std::exception& e) {
91568       {
91569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91570       };
91571     } catch (...) {
91572       {
91573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91574       };
91575     }
91576   }
91577   jresult = result;
91578   return jresult;
91579 }
91580
91581
91582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VideoViewSignal_GetConnectionCount(void * jarg1) {
91583   unsigned long jresult ;
91584   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91585   std::size_t result;
91586
91587   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91588   {
91589     try {
91590       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91591     } catch (std::out_of_range& e) {
91592       {
91593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91594       };
91595     } catch (std::exception& e) {
91596       {
91597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91598       };
91599     } catch (...) {
91600       {
91601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91602       };
91603     }
91604   }
91605   jresult = (unsigned long)result;
91606   return jresult;
91607 }
91608
91609
91610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91611   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91612   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91613
91614   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91615   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91616   {
91617     try {
91618       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91619     } catch (std::out_of_range& e) {
91620       {
91621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91622       };
91623     } catch (std::exception& e) {
91624       {
91625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91626       };
91627     } catch (...) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91630       };
91631     }
91632   }
91633 }
91634
91635
91636 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91637   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91638   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91639
91640   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91641   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91642   {
91643     try {
91644       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91645     } catch (std::out_of_range& e) {
91646       {
91647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91648       };
91649     } catch (std::exception& e) {
91650       {
91651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91652       };
91653     } catch (...) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91656       };
91657     }
91658   }
91659 }
91660
91661
91662 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91663   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91664   Dali::Toolkit::VideoView *arg2 = 0 ;
91665
91666   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91667   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91668   if (!arg2) {
91669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91670     return ;
91671   }
91672   {
91673     try {
91674       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91675     } catch (std::out_of_range& e) {
91676       {
91677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91678       };
91679     } catch (std::exception& e) {
91680       {
91681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91682       };
91683     } catch (...) {
91684       {
91685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91686       };
91687     }
91688   }
91689 }
91690
91691
91692 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoViewSignal() {
91693   void * jresult ;
91694   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91695
91696   {
91697     try {
91698       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91699     } catch (std::out_of_range& e) {
91700       {
91701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91702       };
91703     } catch (std::exception& e) {
91704       {
91705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91706       };
91707     } catch (...) {
91708       {
91709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91710       };
91711     }
91712   }
91713   jresult = (void *)result;
91714   return jresult;
91715 }
91716
91717
91718 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoViewSignal(void * jarg1) {
91719   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91720
91721   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91722   {
91723     try {
91724       delete arg1;
91725     } catch (std::out_of_range& e) {
91726       {
91727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91728       };
91729     } catch (std::exception& e) {
91730       {
91731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91736       };
91737     }
91738   }
91739 }
91740
91741
91742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Empty(void * jarg1) {
91743   unsigned int jresult ;
91744   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91745   bool result;
91746
91747   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91748   {
91749     try {
91750       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91751     } catch (std::out_of_range& e) {
91752       {
91753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91754       };
91755     } catch (std::exception& e) {
91756       {
91757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91758       };
91759     } catch (...) {
91760       {
91761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91762       };
91763     }
91764   }
91765   jresult = result;
91766   return jresult;
91767 }
91768
91769
91770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91771   unsigned long jresult ;
91772   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91773   std::size_t result;
91774
91775   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91776   {
91777     try {
91778       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91779     } catch (std::out_of_range& e) {
91780       {
91781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91782       };
91783     } catch (std::exception& e) {
91784       {
91785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91786       };
91787     } catch (...) {
91788       {
91789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91790       };
91791     }
91792   }
91793   jresult = (unsigned long)result;
91794   return jresult;
91795 }
91796
91797
91798 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91799   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91800   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91801
91802   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91803   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91804   {
91805     try {
91806       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91807     } catch (std::out_of_range& e) {
91808       {
91809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91810       };
91811     } catch (std::exception& e) {
91812       {
91813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91814       };
91815     } catch (...) {
91816       {
91817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91818       };
91819     }
91820   }
91821 }
91822
91823
91824 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91825   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91826   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91827
91828   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91829   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91830   {
91831     try {
91832       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91833     } catch (std::out_of_range& e) {
91834       {
91835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91836       };
91837     } catch (std::exception& e) {
91838       {
91839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91840       };
91841     } catch (...) {
91842       {
91843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91844       };
91845     }
91846   }
91847 }
91848
91849
91850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91851   unsigned int jresult ;
91852   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91853   Dali::Toolkit::Slider arg2 ;
91854   float arg3 ;
91855   Dali::Toolkit::Slider *argp2 ;
91856   bool result;
91857
91858   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91859   argp2 = (Dali::Toolkit::Slider *)jarg2;
91860   if (!argp2) {
91861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91862     return 0;
91863   }
91864   arg2 = *argp2;
91865   arg3 = (float)jarg3;
91866   {
91867     try {
91868       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91869     } catch (std::out_of_range& e) {
91870       {
91871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91872       };
91873     } catch (std::exception& e) {
91874       {
91875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91876       };
91877     } catch (...) {
91878       {
91879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91880       };
91881     }
91882   }
91883   jresult = result;
91884   return jresult;
91885 }
91886
91887
91888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SliderValueChangedSignal() {
91889   void * jresult ;
91890   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91891
91892   {
91893     try {
91894       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91895     } catch (std::out_of_range& e) {
91896       {
91897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91898       };
91899     } catch (std::exception& e) {
91900       {
91901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91902       };
91903     } catch (...) {
91904       {
91905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91906       };
91907     }
91908   }
91909   jresult = (void *)result;
91910   return jresult;
91911 }
91912
91913
91914 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SliderValueChangedSignal(void * jarg1) {
91915   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91916
91917   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91918   {
91919     try {
91920       delete arg1;
91921     } catch (std::out_of_range& e) {
91922       {
91923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91924       };
91925     } catch (std::exception& e) {
91926       {
91927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91928       };
91929     } catch (...) {
91930       {
91931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91932       };
91933     }
91934   }
91935 }
91936
91937
91938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Empty(void * jarg1) {
91939   unsigned int jresult ;
91940   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91941   bool result;
91942
91943   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91944   {
91945     try {
91946       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91947     } catch (std::out_of_range& e) {
91948       {
91949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (std::exception& e) {
91952       {
91953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91954       };
91955     } catch (...) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91958       };
91959     }
91960   }
91961   jresult = result;
91962   return jresult;
91963 }
91964
91965
91966 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91967   unsigned long jresult ;
91968   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91969   std::size_t result;
91970
91971   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91972   {
91973     try {
91974       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91975     } catch (std::out_of_range& e) {
91976       {
91977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91978       };
91979     } catch (std::exception& e) {
91980       {
91981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91982       };
91983     } catch (...) {
91984       {
91985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91986       };
91987     }
91988   }
91989   jresult = (unsigned long)result;
91990   return jresult;
91991 }
91992
91993
91994 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91995   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91996   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91997
91998   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91999   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92000   {
92001     try {
92002       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92003     } catch (std::out_of_range& e) {
92004       {
92005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92006       };
92007     } catch (std::exception& e) {
92008       {
92009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92010       };
92011     } catch (...) {
92012       {
92013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92014       };
92015     }
92016   }
92017 }
92018
92019
92020 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92021   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92022   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92023
92024   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92025   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92026   {
92027     try {
92028       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92029     } catch (std::out_of_range& e) {
92030       {
92031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92032       };
92033     } catch (std::exception& e) {
92034       {
92035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92036       };
92037     } catch (...) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92040       };
92041     }
92042   }
92043 }
92044
92045
92046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92047   unsigned int jresult ;
92048   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92049   Dali::Toolkit::Slider arg2 ;
92050   int arg3 ;
92051   Dali::Toolkit::Slider *argp2 ;
92052   bool result;
92053
92054   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92055   argp2 = (Dali::Toolkit::Slider *)jarg2;
92056   if (!argp2) {
92057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92058     return 0;
92059   }
92060   arg2 = *argp2;
92061   arg3 = (int)jarg3;
92062   {
92063     try {
92064       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92065     } catch (std::out_of_range& e) {
92066       {
92067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92068       };
92069     } catch (std::exception& e) {
92070       {
92071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92072       };
92073     } catch (...) {
92074       {
92075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92076       };
92077     }
92078   }
92079   jresult = result;
92080   return jresult;
92081 }
92082
92083
92084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SliderMarkReachedSignal() {
92085   void * jresult ;
92086   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92087
92088   {
92089     try {
92090       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92091     } catch (std::out_of_range& e) {
92092       {
92093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92094       };
92095     } catch (std::exception& e) {
92096       {
92097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92098       };
92099     } catch (...) {
92100       {
92101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92102       };
92103     }
92104   }
92105   jresult = (void *)result;
92106   return jresult;
92107 }
92108
92109
92110 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SliderMarkReachedSignal(void * jarg1) {
92111   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92112
92113   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92114   {
92115     try {
92116       delete arg1;
92117     } catch (std::out_of_range& e) {
92118       {
92119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92120       };
92121     } catch (std::exception& e) {
92122       {
92123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92124       };
92125     } catch (...) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92128       };
92129     }
92130   }
92131 }
92132
92133
92134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_0() {
92135   void * jresult ;
92136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92137
92138   {
92139     try {
92140       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92141     } catch (std::out_of_range& e) {
92142       {
92143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92144       };
92145     } catch (std::exception& e) {
92146       {
92147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92148       };
92149     } catch (...) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92152       };
92153     }
92154   }
92155   jresult = (void *)result;
92156   return jresult;
92157 }
92158
92159
92160 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_1(void * jarg1) {
92161   void * jresult ;
92162   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92164
92165   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92166   {
92167     try {
92168       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92169     } catch (std::out_of_range& e) {
92170       {
92171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92172       };
92173     } catch (std::exception& e) {
92174       {
92175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92176       };
92177     } catch (...) {
92178       {
92179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92180       };
92181     }
92182   }
92183   jresult = (void *)result;
92184   return jresult;
92185 }
92186
92187
92188 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_2(void * jarg1) {
92189   void * jresult ;
92190   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92191   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92192
92193   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92194   if (!arg1) {
92195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92196     return 0;
92197   }
92198   {
92199     try {
92200       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92201     } catch (std::out_of_range& e) {
92202       {
92203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92204       };
92205     } catch (std::exception& e) {
92206       {
92207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92208       };
92209     } catch (...) {
92210       {
92211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92212       };
92213     }
92214   }
92215   jresult = (void *)result;
92216   return jresult;
92217 }
92218
92219
92220 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RulerPtr(void * jarg1) {
92221   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92222
92223   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92224   {
92225     try {
92226       delete arg1;
92227     } catch (std::out_of_range& e) {
92228       {
92229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92230       };
92231     } catch (std::exception& e) {
92232       {
92233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92234       };
92235     } catch (...) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92238       };
92239     }
92240   }
92241 }
92242
92243
92244 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Get(void * jarg1) {
92245   void * jresult ;
92246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92247   Dali::Toolkit::Ruler *result = 0 ;
92248
92249   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92250   {
92251     try {
92252       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92253     } catch (std::out_of_range& e) {
92254       {
92255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92256       };
92257     } catch (std::exception& e) {
92258       {
92259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92260       };
92261     } catch (...) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92264       };
92265     }
92266   }
92267   jresult = (void *)result;
92268   return jresult;
92269 }
92270
92271
92272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr___deref__(void * jarg1) {
92273   void * jresult ;
92274   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92275   Dali::Toolkit::Ruler *result = 0 ;
92276
92277   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92278   {
92279     try {
92280       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92281     } catch (std::out_of_range& e) {
92282       {
92283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92284       };
92285     } catch (std::exception& e) {
92286       {
92287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92288       };
92289     } catch (...) {
92290       {
92291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92292       };
92293     }
92294   }
92295   jresult = (void *)result;
92296   return jresult;
92297 }
92298
92299
92300 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr___ref__(void * jarg1) {
92301   void * jresult ;
92302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92303   Dali::Toolkit::Ruler *result = 0 ;
92304
92305   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92306   {
92307     try {
92308       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92309     } catch (std::out_of_range& e) {
92310       {
92311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92312       };
92313     } catch (std::exception& e) {
92314       {
92315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92316       };
92317     } catch (...) {
92318       {
92319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92320       };
92321     }
92322   }
92323   jresult = (void *)result;
92324   return jresult;
92325 }
92326
92327
92328 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92329   void * jresult ;
92330   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92331   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92333
92334   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92335   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92336   if (!arg2) {
92337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92338     return 0;
92339   }
92340   {
92341     try {
92342       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92343     } catch (std::out_of_range& e) {
92344       {
92345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92346       };
92347     } catch (std::exception& e) {
92348       {
92349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92350       };
92351     } catch (...) {
92352       {
92353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92354       };
92355     }
92356   }
92357   jresult = (void *)result;
92358   return jresult;
92359 }
92360
92361
92362 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92363   void * jresult ;
92364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92365   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92366   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92367
92368   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92369   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92370   {
92371     try {
92372       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92373     } catch (std::out_of_range& e) {
92374       {
92375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92376       };
92377     } catch (std::exception& e) {
92378       {
92379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92380       };
92381     } catch (...) {
92382       {
92383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92384       };
92385     }
92386   }
92387   jresult = (void *)result;
92388   return jresult;
92389 }
92390
92391
92392 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reset__SWIG_0(void * jarg1) {
92393   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92394
92395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92396   {
92397     try {
92398       (arg1)->Reset();
92399     } catch (std::out_of_range& e) {
92400       {
92401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92402       };
92403     } catch (std::exception& e) {
92404       {
92405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92406       };
92407     } catch (...) {
92408       {
92409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92410       };
92411     }
92412   }
92413 }
92414
92415
92416 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92417   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92418   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92419
92420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92421   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92422   {
92423     try {
92424       (arg1)->Reset(arg2);
92425     } catch (std::out_of_range& e) {
92426       {
92427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92428       };
92429     } catch (std::exception& e) {
92430       {
92431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92432       };
92433     } catch (...) {
92434       {
92435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92436       };
92437     }
92438   }
92439 }
92440
92441
92442 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Detach(void * jarg1) {
92443   void * jresult ;
92444   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92445   Dali::Toolkit::Ruler *result = 0 ;
92446
92447   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92448   {
92449     try {
92450       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92451     } catch (std::out_of_range& e) {
92452       {
92453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92454       };
92455     } catch (std::exception& e) {
92456       {
92457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92458       };
92459     } catch (...) {
92460       {
92461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92462       };
92463     }
92464   }
92465   jresult = (void *)result;
92466   return jresult;
92467 }
92468
92469
92470 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92471   float jresult ;
92472   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92473   float arg2 ;
92474   float arg3 ;
92475   float result;
92476
92477   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92478   arg2 = (float)jarg2;
92479   arg3 = (float)jarg3;
92480   {
92481     try {
92482       result = (float)(*arg1)->Snap(arg2,arg3);
92483     } catch (std::out_of_range& e) {
92484       {
92485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92486       };
92487     } catch (std::exception& e) {
92488       {
92489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92490       };
92491     } catch (...) {
92492       {
92493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92494       };
92495     }
92496   }
92497   jresult = result;
92498   return jresult;
92499 }
92500
92501
92502 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92503   float jresult ;
92504   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92505   float arg2 ;
92506   float result;
92507
92508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92509   arg2 = (float)jarg2;
92510   {
92511     try {
92512       result = (float)(*arg1)->Snap(arg2);
92513     } catch (std::out_of_range& e) {
92514       {
92515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92516       };
92517     } catch (std::exception& e) {
92518       {
92519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92520       };
92521     } catch (...) {
92522       {
92523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92524       };
92525     }
92526   }
92527   jresult = result;
92528   return jresult;
92529 }
92530
92531
92532 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92533   float jresult ;
92534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92535   unsigned int arg2 ;
92536   unsigned int *arg3 = 0 ;
92537   bool arg4 ;
92538   float result;
92539
92540   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92541   arg2 = (unsigned int)jarg2;
92542   arg3 = (unsigned int *)jarg3;
92543   arg4 = jarg4 ? true : false;
92544   {
92545     try {
92546       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92547     } catch (std::out_of_range& e) {
92548       {
92549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92550       };
92551     } catch (std::exception& e) {
92552       {
92553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92554       };
92555     } catch (...) {
92556       {
92557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92558       };
92559     }
92560   }
92561   jresult = result;
92562   return jresult;
92563 }
92564
92565
92566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92567   unsigned int jresult ;
92568   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92569   float arg2 ;
92570   bool arg3 ;
92571   unsigned int result;
92572
92573   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92574   arg2 = (float)jarg2;
92575   arg3 = jarg3 ? true : false;
92576   {
92577     try {
92578       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92579     } catch (std::out_of_range& e) {
92580       {
92581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92582       };
92583     } catch (std::exception& e) {
92584       {
92585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92586       };
92587     } catch (...) {
92588       {
92589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92590       };
92591     }
92592   }
92593   jresult = result;
92594   return jresult;
92595 }
92596
92597
92598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_GetTotalPages(void * jarg1) {
92599   unsigned int jresult ;
92600   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92601   unsigned int result;
92602
92603   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92604   {
92605     try {
92606       result = (unsigned int)(*arg1)->GetTotalPages();
92607     } catch (std::out_of_range& e) {
92608       {
92609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92610       };
92611     } catch (std::exception& e) {
92612       {
92613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (...) {
92616       {
92617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92618       };
92619     }
92620   }
92621   jresult = result;
92622   return jresult;
92623 }
92624
92625
92626 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RulerPtr_GetType(void * jarg1) {
92627   int jresult ;
92628   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92629   Dali::Toolkit::Ruler::RulerType result;
92630
92631   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92632   {
92633     try {
92634       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92635     } catch (std::out_of_range& e) {
92636       {
92637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92638       };
92639     } catch (std::exception& e) {
92640       {
92641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92642       };
92643     } catch (...) {
92644       {
92645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92646       };
92647     }
92648   }
92649   jresult = (int)result;
92650   return jresult;
92651 }
92652
92653
92654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_IsEnabled(void * jarg1) {
92655   unsigned int jresult ;
92656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92657   bool result;
92658
92659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92660   {
92661     try {
92662       result = (bool)(*arg1)->IsEnabled();
92663     } catch (std::out_of_range& e) {
92664       {
92665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92666       };
92667     } catch (std::exception& e) {
92668       {
92669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92670       };
92671     } catch (...) {
92672       {
92673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92674       };
92675     }
92676   }
92677   jresult = result;
92678   return jresult;
92679 }
92680
92681
92682 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Enable(void * jarg1) {
92683   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92684
92685   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92686   {
92687     try {
92688       (*arg1)->Enable();
92689     } catch (std::out_of_range& e) {
92690       {
92691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92692       };
92693     } catch (std::exception& e) {
92694       {
92695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92696       };
92697     } catch (...) {
92698       {
92699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92700       };
92701     }
92702   }
92703 }
92704
92705
92706 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Disable(void * jarg1) {
92707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92708
92709   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92710   {
92711     try {
92712       (*arg1)->Disable();
92713     } catch (std::out_of_range& e) {
92714       {
92715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92716       };
92717     } catch (std::exception& e) {
92718       {
92719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92720       };
92721     } catch (...) {
92722       {
92723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92724       };
92725     }
92726   }
92727 }
92728
92729
92730 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92731   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92732   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92733   Dali::Toolkit::RulerDomain *argp2 ;
92734
92735   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92736   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92737   if (!argp2) {
92738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92739     return ;
92740   }
92741   arg2 = *argp2;
92742   {
92743     try {
92744       (*arg1)->SetDomain(arg2);
92745     } catch (std::out_of_range& e) {
92746       {
92747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92748       };
92749     } catch (std::exception& e) {
92750       {
92751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92752       };
92753     } catch (...) {
92754       {
92755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92756       };
92757     }
92758   }
92759 }
92760
92761
92762 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_GetDomain(void * jarg1) {
92763   void * jresult ;
92764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92765   Dali::Toolkit::RulerDomain *result = 0 ;
92766
92767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92768   {
92769     try {
92770       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92771     } catch (std::out_of_range& e) {
92772       {
92773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92774       };
92775     } catch (std::exception& e) {
92776       {
92777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92778       };
92779     } catch (...) {
92780       {
92781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92782       };
92783     }
92784   }
92785   jresult = (void *)result;
92786   return jresult;
92787 }
92788
92789
92790 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_DisableDomain(void * jarg1) {
92791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92792
92793   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92794   {
92795     try {
92796       (*arg1)->DisableDomain();
92797     } catch (std::out_of_range& e) {
92798       {
92799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92800       };
92801     } catch (std::exception& e) {
92802       {
92803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92804       };
92805     } catch (...) {
92806       {
92807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92808       };
92809     }
92810   }
92811 }
92812
92813
92814 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92815   float jresult ;
92816   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92817   float arg2 ;
92818   float arg3 ;
92819   float arg4 ;
92820   float result;
92821
92822   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92823   arg2 = (float)jarg2;
92824   arg3 = (float)jarg3;
92825   arg4 = (float)jarg4;
92826   {
92827     try {
92828       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92829     } catch (std::out_of_range& e) {
92830       {
92831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92832       };
92833     } catch (std::exception& e) {
92834       {
92835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92836       };
92837     } catch (...) {
92838       {
92839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92840       };
92841     }
92842   }
92843   jresult = result;
92844   return jresult;
92845 }
92846
92847
92848 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92849   float jresult ;
92850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92851   float arg2 ;
92852   float arg3 ;
92853   float result;
92854
92855   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92856   arg2 = (float)jarg2;
92857   arg3 = (float)jarg3;
92858   {
92859     try {
92860       result = (float)(*arg1)->Clamp(arg2,arg3);
92861     } catch (std::out_of_range& e) {
92862       {
92863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92864       };
92865     } catch (std::exception& e) {
92866       {
92867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92868       };
92869     } catch (...) {
92870       {
92871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92872       };
92873     }
92874   }
92875   jresult = result;
92876   return jresult;
92877 }
92878
92879
92880 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92881   float jresult ;
92882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92883   float arg2 ;
92884   float result;
92885
92886   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92887   arg2 = (float)jarg2;
92888   {
92889     try {
92890       result = (float)(*arg1)->Clamp(arg2);
92891     } catch (std::out_of_range& e) {
92892       {
92893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92894       };
92895     } catch (std::exception& e) {
92896       {
92897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92898       };
92899     } catch (...) {
92900       {
92901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92902       };
92903     }
92904   }
92905   jresult = result;
92906   return jresult;
92907 }
92908
92909
92910 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92911   float jresult ;
92912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92913   float arg2 ;
92914   float arg3 ;
92915   float arg4 ;
92916   Dali::Toolkit::ClampState *arg5 = 0 ;
92917   float result;
92918
92919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92920   arg2 = (float)jarg2;
92921   arg3 = (float)jarg3;
92922   arg4 = (float)jarg4;
92923   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92924   if (!arg5) {
92925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92926     return 0;
92927   }
92928   {
92929     try {
92930       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92931     } catch (std::out_of_range& e) {
92932       {
92933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92934       };
92935     } catch (std::exception& e) {
92936       {
92937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (...) {
92940       {
92941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92942       };
92943     }
92944   }
92945   jresult = result;
92946   return jresult;
92947 }
92948
92949
92950 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92951   float jresult ;
92952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92953   float arg2 ;
92954   float arg3 ;
92955   float arg4 ;
92956   float arg5 ;
92957   float result;
92958
92959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92960   arg2 = (float)jarg2;
92961   arg3 = (float)jarg3;
92962   arg4 = (float)jarg4;
92963   arg5 = (float)jarg5;
92964   {
92965     try {
92966       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92967     } catch (std::out_of_range& e) {
92968       {
92969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92970       };
92971     } catch (std::exception& e) {
92972       {
92973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92974       };
92975     } catch (...) {
92976       {
92977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92978       };
92979     }
92980   }
92981   jresult = result;
92982   return jresult;
92983 }
92984
92985
92986 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92987   float jresult ;
92988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92989   float arg2 ;
92990   float arg3 ;
92991   float arg4 ;
92992   float result;
92993
92994   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92995   arg2 = (float)jarg2;
92996   arg3 = (float)jarg3;
92997   arg4 = (float)jarg4;
92998   {
92999     try {
93000       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93001     } catch (std::out_of_range& e) {
93002       {
93003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93004       };
93005     } catch (std::exception& e) {
93006       {
93007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93008       };
93009     } catch (...) {
93010       {
93011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93012       };
93013     }
93014   }
93015   jresult = result;
93016   return jresult;
93017 }
93018
93019
93020 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93021   float jresult ;
93022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93023   float arg2 ;
93024   float arg3 ;
93025   float result;
93026
93027   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93028   arg2 = (float)jarg2;
93029   arg3 = (float)jarg3;
93030   {
93031     try {
93032       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93033     } catch (std::out_of_range& e) {
93034       {
93035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93036       };
93037     } catch (std::exception& e) {
93038       {
93039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93040       };
93041     } catch (...) {
93042       {
93043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93044       };
93045     }
93046   }
93047   jresult = result;
93048   return jresult;
93049 }
93050
93051
93052 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93053   float jresult ;
93054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93055   float arg2 ;
93056   float result;
93057
93058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93059   arg2 = (float)jarg2;
93060   {
93061     try {
93062       result = (float)(*arg1)->SnapAndClamp(arg2);
93063     } catch (std::out_of_range& e) {
93064       {
93065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93066       };
93067     } catch (std::exception& e) {
93068       {
93069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93070       };
93071     } catch (...) {
93072       {
93073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93074       };
93075     }
93076   }
93077   jresult = result;
93078   return jresult;
93079 }
93080
93081
93082 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93083   float jresult ;
93084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93085   float arg2 ;
93086   float arg3 ;
93087   float arg4 ;
93088   float arg5 ;
93089   Dali::Toolkit::ClampState *arg6 = 0 ;
93090   float result;
93091
93092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93093   arg2 = (float)jarg2;
93094   arg3 = (float)jarg3;
93095   arg4 = (float)jarg4;
93096   arg5 = (float)jarg5;
93097   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93098   if (!arg6) {
93099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93100     return 0;
93101   }
93102   {
93103     try {
93104       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93105     } catch (std::out_of_range& e) {
93106       {
93107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93108       };
93109     } catch (std::exception& e) {
93110       {
93111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93112       };
93113     } catch (...) {
93114       {
93115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93116       };
93117     }
93118   }
93119   jresult = result;
93120   return jresult;
93121 }
93122
93123
93124 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reference(void * jarg1) {
93125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93126
93127   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93128   {
93129     try {
93130       (*arg1)->Reference();
93131     } catch (std::out_of_range& e) {
93132       {
93133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93134       };
93135     } catch (std::exception& e) {
93136       {
93137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93138       };
93139     } catch (...) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93142       };
93143     }
93144   }
93145 }
93146
93147
93148 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Unreference(void * jarg1) {
93149   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93150
93151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93152   {
93153     try {
93154       (*arg1)->Unreference();
93155     } catch (std::out_of_range& e) {
93156       {
93157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93158       };
93159     } catch (std::exception& e) {
93160       {
93161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93162       };
93163     } catch (...) {
93164       {
93165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93166       };
93167     }
93168   }
93169 }
93170
93171
93172 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RulerPtr_ReferenceCount(void * jarg1) {
93173   int jresult ;
93174   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93175   int result;
93176
93177   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93178   {
93179     try {
93180       result = (int)(*arg1)->ReferenceCount();
93181     } catch (std::out_of_range& e) {
93182       {
93183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93184       };
93185     } catch (std::exception& e) {
93186       {
93187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93188       };
93189     } catch (...) {
93190       {
93191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93192       };
93193     }
93194   }
93195   jresult = result;
93196   return jresult;
93197 }
93198
93199
93200 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
93201     return (Dali::RefObject *)jarg1;
93202 }
93203
93204 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_NUI_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
93205     return (Dali::SignalObserver *)jarg1;
93206 }
93207
93208 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_NUI_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
93209     return (Dali::ConnectionTrackerInterface *)jarg1;
93210 }
93211
93212 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
93213     return (Dali::BaseHandle *)jarg1;
93214 }
93215
93216 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
93217     return (Dali::BaseHandle *)jarg1;
93218 }
93219
93220 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
93221     return (Dali::BaseHandle *)jarg1;
93222 }
93223
93224 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Handle_SWIGUpcast(Dali::Handle *jarg1) {
93225     return (Dali::BaseHandle *)jarg1;
93226 }
93227
93228 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
93229     return (Dali::BaseHandle *)jarg1;
93230 }
93231
93232 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
93233     return (Dali::BaseHandle *)jarg1;
93234 }
93235
93236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Image_SWIGUpcast(Dali::Image *jarg1) {
93237     return (Dali::BaseHandle *)jarg1;
93238 }
93239
93240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
93241     return (Dali::BaseHandle *)jarg1;
93242 }
93243
93244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Texture_SWIGUpcast(Dali::Texture *jarg1) {
93245     return (Dali::BaseHandle *)jarg1;
93246 }
93247
93248 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
93249     return (Dali::BaseHandle *)jarg1;
93250 }
93251
93252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
93253     return (Dali::BaseHandle *)jarg1;
93254 }
93255
93256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93257     return (Dali::BaseHandle *)jarg1;
93258 }
93259
93260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93261     return (Dali::BaseHandle *)jarg1;
93262 }
93263
93264 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93265     return (Dali::Handle *)jarg1;
93266 }
93267
93268 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93269     return (Dali::Handle *)jarg1;
93270 }
93271
93272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93273     return (Dali::BaseHandle *)jarg1;
93274 }
93275
93276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93277     return (Dali::BaseHandle *)jarg1;
93278 }
93279
93280 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93281     return (Dali::Handle *)jarg1;
93282 }
93283
93284 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TouchData_SWIGUpcast(Dali::TouchData *jarg1) {
93285     return (Dali::BaseHandle *)jarg1;
93286 }
93287
93288 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93289     return (Dali::Handle *)jarg1;
93290 }
93291
93292 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93293     return (Dali::GestureDetector *)jarg1;
93294 }
93295
93296 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93297     return (Dali::Gesture *)jarg1;
93298 }
93299
93300 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93301     return (Dali::Handle *)jarg1;
93302 }
93303
93304 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93305     return (Dali::Actor *)jarg1;
93306 }
93307
93308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93309     return (Dali::BaseHandle *)jarg1;
93310 }
93311
93312 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93313     return (Dali::RefObject *)jarg1;
93314 }
93315
93316 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93317     return (Dali::Actor *)jarg1;
93318 }
93319
93320 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93321     return (Dali::GestureDetector *)jarg1;
93322 }
93323
93324 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93325     return (Dali::Gesture *)jarg1;
93326 }
93327
93328 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93329     return (Dali::GestureDetector *)jarg1;
93330 }
93331
93332 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93333     return (Dali::Gesture *)jarg1;
93334 }
93335
93336 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93337     return (Dali::GestureDetector *)jarg1;
93338 }
93339
93340 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93341     return (Dali::Gesture *)jarg1;
93342 }
93343
93344 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93345     return (Dali::BaseHandle *)jarg1;
93346 }
93347
93348 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Path_SWIGUpcast(Dali::Path *jarg1) {
93349     return (Dali::Handle *)jarg1;
93350 }
93351
93352 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93353     return (Dali::BaseHandle *)jarg1;
93354 }
93355
93356 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93357     return (Dali::Handle *)jarg1;
93358 }
93359
93360 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93361     return (Dali::Handle *)jarg1;
93362 }
93363
93364 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93365     return (Dali::Image *)jarg1;
93366 }
93367
93368 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93369     return (Dali::Image *)jarg1;
93370 }
93371
93372 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93373     return (Dali::Image *)jarg1;
93374 }
93375
93376 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93377     return (Dali::RefObject *)jarg1;
93378 }
93379
93380 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93381     return (Dali::Image *)jarg1;
93382 }
93383
93384 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93385     return (Dali::Image *)jarg1;
93386 }
93387
93388 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_NUI_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93389     return (Dali::ResourceImage *)jarg1;
93390 }
93391
93392 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93393     return (Dali::Actor *)jarg1;
93394 }
93395
93396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93397     return (Dali::BaseHandle *)jarg1;
93398 }
93399
93400 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93401     return (Dali::BaseHandle *)jarg1;
93402 }
93403
93404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Window_SWIGUpcast(Dali::Window *jarg1) {
93405     return (Dali::BaseHandle *)jarg1;
93406 }
93407
93408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Application_SWIGUpcast(Dali::Application *jarg1) {
93409     return (Dali::BaseHandle *)jarg1;
93410 }
93411
93412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93413     return (Dali::BaseHandle *)jarg1;
93414 }
93415
93416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93417     return (Dali::BaseHandle *)jarg1;
93418 }
93419
93420 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_NUI_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93421     return (Dali::CustomActorImpl *)jarg1;
93422 }
93423
93424 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_NUI_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93425     return (Dali::CustomActor *)jarg1;
93426 }
93427
93428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93429     return (Dali::BaseHandle *)jarg1;
93430 }
93431
93432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93433     return (Dali::Toolkit::Control *)jarg1;
93434 }
93435
93436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93437     return (Dali::Toolkit::Control *)jarg1;
93438 }
93439
93440 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93441     return (Dali::Toolkit::Button *)jarg1;
93442 }
93443
93444 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93445     return (Dali::Toolkit::Button *)jarg1;
93446 }
93447
93448 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93449     return (Dali::Toolkit::Button *)jarg1;
93450 }
93451
93452 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93453     return (Dali::Toolkit::Control *)jarg1;
93454 }
93455
93456 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93457     return (Dali::Toolkit::Control *)jarg1;
93458 }
93459
93460 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93461     return (Dali::Toolkit::Control *)jarg1;
93462 }
93463
93464 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93465     return (Dali::Toolkit::Control *)jarg1;
93466 }
93467
93468 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93469     return (Dali::Toolkit::Control *)jarg1;
93470 }
93471
93472 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93473     return (Dali::RefObject *)jarg1;
93474 }
93475
93476 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_NUI_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93477     return (Dali::Toolkit::Scrollable *)jarg1;
93478 }
93479
93480 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93481     return (Dali::BaseHandle *)jarg1;
93482 }
93483
93484 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93485     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93486 }
93487
93488 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93489     return (Dali::RefObject *)jarg1;
93490 }
93491
93492 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_NUI_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93493     return (Dali::Toolkit::Ruler *)jarg1;
93494 }
93495
93496 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_NUI_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93497     return (Dali::Toolkit::Ruler *)jarg1;
93498 }
93499
93500 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_NUI_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93501     return (Dali::Toolkit::Scrollable *)jarg1;
93502 }
93503
93504 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93505     return (Dali::Toolkit::Control *)jarg1;
93506 }
93507
93508 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93509     return (Dali::Toolkit::Control *)jarg1;
93510 }
93511
93512 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93513     return (Dali::Toolkit::Control *)jarg1;
93514 }
93515
93516 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93517     return (Dali::Toolkit::Control *)jarg1;
93518 }
93519
93520 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93521     return (Dali::BaseHandle *)jarg1;
93522 }
93523
93524 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93525     return (Dali::BaseHandle *)jarg1;
93526 }
93527
93528 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93529     return (Dali::Toolkit::Control *)jarg1;
93530 }
93531
93532 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93533     return (Dali::Toolkit::Control *)jarg1;
93534 }
93535
93536 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93537     return (Dali::Toolkit::Control *)jarg1;
93538 }
93539
93540 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93541     return (Dali::Toolkit::Control *)jarg1;
93542 }
93543
93544 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93545     return (Dali::Toolkit::Control *)jarg1;
93546 }
93547
93548 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93549     return (Dali::Toolkit::Control *)jarg1;
93550 }
93551
93552 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93553     return (Dali::Toolkit::PageTurnView *)jarg1;
93554 }
93555
93556 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93557     return (Dali::Toolkit::PageTurnView *)jarg1;
93558 }
93559
93560 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93561     return (Dali::BaseHandle *)jarg1;
93562 }
93563
93564 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93565     return (Dali::BaseHandle *)jarg1;
93566 }
93567
93568 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93569     return (Dali::BaseHandle *)jarg1;
93570 }
93571
93572 #ifdef __cplusplus
93573 }
93574 #endif
93575