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 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 456
 457 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 458
 459 // add here SWIG version check
 460
 461 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 462 // disable Swig-dependent warnings
 463
 464 // 'identifier1' has C-linkage specified,
 465 // but returns UDT 'identifier2' which is incompatible with C
 466 #pragma warning(disable: 4190)
 467
 468 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 469 #pragma warning(disable: 4800)
 470
 471 // debug info too long etc etc
 472 #pragma warning(disable: 4786)
 473 #endif
 474
 475
 476 #include <stdexcept>
 477
 478
 479 #include <string>
 480
 481
 482 #include <vector>
 483 #include <algorithm>
 484 #include <stdexcept>
 485
 486
 487 #include <map>
 488 #include <algorithm>
 489 #include <stdexcept>
 490
 491
 492 #include <utility>
 493
 494
 495 typedef float floatp;
 496
 497 SWIGINTERN floatp *new_floatp(){
 498   return new float();
 499 }
 500 SWIGINTERN void delete_floatp(floatp *self){
 501   if (self) delete self;
 502 }
 503 SWIGINTERN void floatp_assign(floatp *self,float value){
 504   *self = value;
 505 }
 506 SWIGINTERN float floatp_value(floatp *self){
 507   return *self;
 508 }
 509 SWIGINTERN float *floatp_cast(floatp *self){
 510   return self;
 511 }
 512 SWIGINTERN floatp *floatp_frompointer(float *t){
 513   return (floatp *) t;
 514 }
 515
 516 typedef int intp;
 517
 518 SWIGINTERN intp *new_intp(){
 519   return new int();
 520 }
 521 SWIGINTERN void delete_intp(intp *self){
 522   if (self) delete self;
 523 }
 524 SWIGINTERN void intp_assign(intp *self,int value){
 525   *self = value;
 526 }
 527 SWIGINTERN int intp_value(intp *self){
 528   return *self;
 529 }
 530 SWIGINTERN int *intp_cast(intp *self){
 531   return self;
 532 }
 533 SWIGINTERN intp *intp_frompointer(int *t){
 534   return (intp *) t;
 535 }
 536
 537 typedef double doublep;
 538
 539 SWIGINTERN doublep *new_doublep(){
 540   return new double();
 541 }
 542 SWIGINTERN void delete_doublep(doublep *self){
 543   if (self) delete self;
 544 }
 545 SWIGINTERN void doublep_assign(doublep *self,double value){
 546   *self = value;
 547 }
 548 SWIGINTERN double doublep_value(doublep *self){
 549   return *self;
 550 }
 551 SWIGINTERN double *doublep_cast(doublep *self){
 552   return self;
 553 }
 554 SWIGINTERN doublep *doublep_frompointer(double *t){
 555   return (doublep *) t;
 556 }
 557
 558 typedef unsigned int uintp;
 559
 560 SWIGINTERN uintp *new_uintp(){
 561   return new unsigned int();
 562 }
 563 SWIGINTERN void delete_uintp(uintp *self){
 564   if (self) delete self;
 565 }
 566 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 567   *self = value;
 568 }
 569 SWIGINTERN unsigned int uintp_value(uintp *self){
 570   return *self;
 571 }
 572 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 573   return self;
 574 }
 575 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 576   return (uintp *) t;
 577 }
 578
 579 typedef unsigned short ushortp;
 580
 581 SWIGINTERN ushortp *new_ushortp(){
 582   return new unsigned short();
 583 }
 584 SWIGINTERN void delete_ushortp(ushortp *self){
 585   if (self) delete self;
 586 }
 587 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 588   *self = value;
 589 }
 590 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 591   return *self;
 592 }
 593 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 594   return self;
 595 }
 596 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 597   return (ushortp *) t;
 598 }
 599
 600 unsigned int int_to_uint(int x) {
 601    return (unsigned int) x;
 602 }
 603
 604
 605 using namespace Dali;
 606 using namespace Dali::Toolkit;
 607
 608 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 609
 610      // C++ code. DALi uses Handle <-> Body design pattern.
 611      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 612      // Handles in DALi can be converted into a boolean type
 613      // to check if the handle has a valid body attached to it.
 614      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 615      if( *self )
 616      {
 617        return true;
 618      }
 619      else
 620      {
 621        return false;
 622      }
 623     }
 624 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 625
 626      // C++ code. Check if two handles reference the same implemtion
 627      if( *self == rhs)
 628      {
 629        return true;
 630      }
 631      else
 632      {
 633        return false;
 634      }
 635     }
 636 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 637         std::vector< Dali::TouchPoint >* pv = 0;
 638         if (capacity >= 0) {
 639           pv = new std::vector< Dali::TouchPoint >();
 640           pv->reserve(capacity);
 641        } else {
 642           throw std::out_of_range("capacity");
 643        }
 644        return pv;
 645       }
 646 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 647         if (index>=0 && index<(int)self->size())
 648           return (*self)[index];
 649         else
 650           throw std::out_of_range("index");
 651       }
 652 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 653         if (index>=0 && index<(int)self->size())
 654           return (*self)[index];
 655         else
 656           throw std::out_of_range("index");
 657       }
 658 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 659         if (index>=0 && index<(int)self->size())
 660           (*self)[index] = val;
 661         else
 662           throw std::out_of_range("index");
 663       }
 664 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 665         self->insert(self->end(), values.begin(), values.end());
 666       }
 667 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 668         if (index < 0)
 669           throw std::out_of_range("index");
 670         if (count < 0)
 671           throw std::out_of_range("count");
 672         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 673           throw std::invalid_argument("invalid range");
 674         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 675       }
 676 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 677         if (index>=0 && index<(int)self->size()+1)
 678           self->insert(self->begin()+index, x);
 679         else
 680           throw std::out_of_range("index");
 681       }
 682 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 683         if (index>=0 && index<(int)self->size()+1)
 684           self->insert(self->begin()+index, values.begin(), values.end());
 685         else
 686           throw std::out_of_range("index");
 687       }
 688 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 689         if (index>=0 && index<(int)self->size())
 690           self->erase(self->begin() + index);
 691         else
 692           throw std::out_of_range("index");
 693       }
 694 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 695         if (index < 0)
 696           throw std::out_of_range("index");
 697         if (count < 0)
 698           throw std::out_of_range("count");
 699         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 700           throw std::invalid_argument("invalid range");
 701         self->erase(self->begin()+index, self->begin()+index+count);
 702       }
 703 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 704         if (count < 0)
 705           throw std::out_of_range("count");
 706         return new std::vector< Dali::TouchPoint >(count, value);
 707       }
 708 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 709         std::reverse(self->begin(), self->end());
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 712         if (index < 0)
 713           throw std::out_of_range("index");
 714         if (count < 0)
 715           throw std::out_of_range("count");
 716         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 717           throw std::invalid_argument("invalid range");
 718         std::reverse(self->begin()+index, self->begin()+index+count);
 719       }
 720 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 721         if (index < 0)
 722           throw std::out_of_range("index");
 723         if (index+values.size() > self->size())
 724           throw std::out_of_range("index");
 725         std::copy(values.begin(), values.end(), self->begin()+index);
 726       }
 727 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 728          return self->Empty();
 729       }
 730 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 731         return self->GetConnectionCount();
 732       }
 733 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 734           self->Connect( func );
 735       }
 736 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 737           self->Disconnect( func );
 738       }
 739 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 740           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 741 /*@SWIG@*/ self->Emit( arg );
 742       }
 743 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 744          return self->Empty();
 745       }
 746 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 747         return self->GetConnectionCount();
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 750           self->Connect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 753           self->Disconnect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 756           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 757 /*@SWIG@*/ self->Emit( arg );
 758       }
 759 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 760          return self->Empty();
 761       }
 762 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){
 763         return self->GetConnectionCount();
 764       }
 765 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 *)){
 766           self->Connect( func );
 767       }
 768 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 *)){
 769           self->Disconnect( func );
 770       }
 771 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){
 772           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 773 /*@SWIG@*/ self->Emit( arg );
 774       }
 775 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 776          return self->Empty();
 777       }
 778 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 779         return self->GetConnectionCount();
 780       }
 781 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 782           self->Connect( func );
 783       }
 784 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 785           self->Disconnect( func );
 786       }
 787 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 788           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 789 /*@SWIG@*/ self->Emit( arg );
 790       }
 791 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 792          return self->Empty();
 793       }
 794 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 795         return self->GetConnectionCount();
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 798           self->Connect( func );
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 801           self->Disconnect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 804           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 805 /*@SWIG@*/ self->Emit( arg );
 806       }
 807 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){
 808          return self->Empty();
 809       }
 810 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){
 811         return self->GetConnectionCount();
 812       }
 813 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 &)){
 814         self->Connect( func );
 815       }
 816 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 &)){
 817         self->Disconnect( func );
 818       }
 819 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){
 820         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 821 /*@SWIG@*/ self->Emit( arg1, arg2 );
 822       }
 823 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){
 824          return self->Empty();
 825       }
 826 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){
 827         return self->GetConnectionCount();
 828       }
 829 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 &)){
 830         self->Connect( func );
 831       }
 832 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 &)){
 833         self->Disconnect( func );
 834       }
 835 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){
 836         return self->Emit( arg1, arg2 );
 837       }
 838 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){
 839          return self->Empty();
 840       }
 841 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){
 842         return self->GetConnectionCount();
 843       }
 844 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 &)){
 845         self->Connect( func );
 846       }
 847 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 &)){
 848         self->Disconnect( func );
 849       }
 850 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){
 851         return self->Emit( arg1, arg2 );
 852       }
 853 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){
 854          return self->Empty();
 855       }
 856 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){
 857         return self->GetConnectionCount();
 858       }
 859 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 &)){
 860         self->Connect( func );
 861       }
 862 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 &)){
 863         self->Disconnect( func );
 864       }
 865 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){
 866         return self->Emit( arg1, arg2 );
 867       }
 868 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 869          return self->Empty();
 870       }
 871 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 872         return self->GetConnectionCount();
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 875           self->Connect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 878           self->Disconnect( func );
 879       }
 880 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 881           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 882 /*@SWIG@*/ self->Emit( arg );
 883       }
 884 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 885          return self->Empty();
 886       }
 887 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){
 888         return self->GetConnectionCount();
 889       }
 890 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 &)){
 891           self->Connect( func );
 892       }
 893 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 &)){
 894           self->Disconnect( func );
 895       }
 896 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){
 897           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 898 /*@SWIG@*/ self->Emit( arg );
 899       }
 900 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 901          return self->Empty();
 902       }
 903 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){
 904         return self->GetConnectionCount();
 905       }
 906 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 &)){
 907           self->Connect( func );
 908       }
 909 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 &)){
 910           self->Disconnect( func );
 911       }
 912 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){
 913           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 914 /*@SWIG@*/ self->Emit( arg );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 917          return self->Empty();
 918       }
 919 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){
 920         return self->GetConnectionCount();
 921       }
 922 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 &)){
 923           self->Connect( func );
 924       }
 925 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 &)){
 926           self->Disconnect( func );
 927       }
 928 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){
 929           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 930 /*@SWIG@*/ self->Emit( arg );
 931       }
 932 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){
 933          return self->Empty();
 934       }
 935 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){
 936         return self->GetConnectionCount();
 937       }
 938 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 &)){
 939         self->Connect( func );
 940       }
 941 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 &)){
 942         self->Disconnect( func );
 943       }
 944 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){
 945         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 946 /*@SWIG@*/ self->Emit( arg1, arg2 );
 947       }
 948 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){
 949          return self->Empty();
 950       }
 951 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){
 952         return self->GetConnectionCount();
 953       }
 954 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 &)){
 955         self->Connect( func );
 956       }
 957 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 &)){
 958         self->Disconnect( func );
 959       }
 960 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){
 961         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg1, arg2 );
 963       }
 964 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){
 965          return self->Empty();
 966       }
 967 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){
 968         return self->GetConnectionCount();
 969       }
 970 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 &)){
 971         self->Connect( func );
 972       }
 973 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 &)){
 974         self->Disconnect( func );
 975       }
 976 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){
 977         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg1, arg2 );
 979       }
 980 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 981          return self->Empty();
 982       }
 983 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 984         return self->GetConnectionCount();
 985       }
 986 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 987           self->Connect( func );
 988       }
 989 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 990           self->Disconnect( func );
 991       }
 992 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
 993           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 997          return self->Empty();
 998       }
 999 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1000         return self->GetConnectionCount();
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1003           self->Connect( func );
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1006           self->Disconnect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012
1013   // keep argcs and argv so they're always available to DALi
1014   int argC = 1;
1015   char **argV = NULL;
1016
1017 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1018          return self->Empty();
1019       }
1020 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1021         return self->GetConnectionCount();
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1024           self->Connect( func );
1025       }
1026 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1027           self->Disconnect( func );
1028       }
1029 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1030           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1031 /*@SWIG@*/ self->Emit( arg );
1032       }
1033 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1034          return self->Empty();
1035       }
1036 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){
1037         return self->GetConnectionCount();
1038       }
1039 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 *)){
1040         self->Connect( func );
1041       }
1042 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 *)){
1043         self->Disconnect( func );
1044       }
1045 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){
1046         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg1, arg2 );
1048       }
1049 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1050         std::vector< unsigned int >* pv = 0;
1051         if (capacity >= 0) {
1052           pv = new std::vector< unsigned int >();
1053           pv->reserve(capacity);
1054        } else {
1055           throw std::out_of_range("capacity");
1056        }
1057        return pv;
1058       }
1059 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1060         if (index>=0 && index<(int)self->size())
1061           return (*self)[index];
1062         else
1063           throw std::out_of_range("index");
1064       }
1065 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1066         if (index>=0 && index<(int)self->size())
1067           return (*self)[index];
1068         else
1069           throw std::out_of_range("index");
1070       }
1071 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1072         if (index>=0 && index<(int)self->size())
1073           (*self)[index] = val;
1074         else
1075           throw std::out_of_range("index");
1076       }
1077 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1078         self->insert(self->end(), values.begin(), values.end());
1079       }
1080 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1081         if (index < 0)
1082           throw std::out_of_range("index");
1083         if (count < 0)
1084           throw std::out_of_range("count");
1085         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1086           throw std::invalid_argument("invalid range");
1087         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1088       }
1089 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1090         if (index>=0 && index<(int)self->size()+1)
1091           self->insert(self->begin()+index, x);
1092         else
1093           throw std::out_of_range("index");
1094       }
1095 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1096         if (index>=0 && index<(int)self->size()+1)
1097           self->insert(self->begin()+index, values.begin(), values.end());
1098         else
1099           throw std::out_of_range("index");
1100       }
1101 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1102         if (index>=0 && index<(int)self->size())
1103           self->erase(self->begin() + index);
1104         else
1105           throw std::out_of_range("index");
1106       }
1107 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1108         if (index < 0)
1109           throw std::out_of_range("index");
1110         if (count < 0)
1111           throw std::out_of_range("count");
1112         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1113           throw std::invalid_argument("invalid range");
1114         self->erase(self->begin()+index, self->begin()+index+count);
1115       }
1116 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1117         if (count < 0)
1118           throw std::out_of_range("count");
1119         return new std::vector< unsigned int >(count, value);
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1122         std::reverse(self->begin(), self->end());
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1125         if (index < 0)
1126           throw std::out_of_range("index");
1127         if (count < 0)
1128           throw std::out_of_range("count");
1129         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1130           throw std::invalid_argument("invalid range");
1131         std::reverse(self->begin()+index, self->begin()+index+count);
1132       }
1133 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1134         if (index < 0)
1135           throw std::out_of_range("index");
1136         if (index+values.size() > self->size())
1137           throw std::out_of_range("index");
1138         std::copy(values.begin(), values.end(), self->begin()+index);
1139       }
1140 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1141         return std::find(self->begin(), self->end(), value) != self->end();
1142       }
1143 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1144         int index = -1;
1145         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1146         if (it != self->end())
1147           index = (int)(it - self->begin());
1148         return index;
1149       }
1150 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1151         int index = -1;
1152         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1153         if (rit != self->rend())
1154           index = (int)(self->rend() - 1 - rit);
1155         return index;
1156       }
1157 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1158         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1159         if (it != self->end()) {
1160           self->erase(it);
1161           return true;
1162         }
1163         return false;
1164       }
1165 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){
1166         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1167         if (capacity >= 0) {
1168           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1169           pv->reserve(capacity);
1170        } else {
1171           throw std::out_of_range("capacity");
1172        }
1173        return pv;
1174       }
1175 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){
1176         if (index>=0 && index<(int)self->size())
1177           return (*self)[index];
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 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){
1182         if (index>=0 && index<(int)self->size())
1183           return (*self)[index];
1184         else
1185           throw std::out_of_range("index");
1186       }
1187 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){
1188         if (index>=0 && index<(int)self->size())
1189           (*self)[index] = val;
1190         else
1191           throw std::out_of_range("index");
1192       }
1193 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){
1194         self->insert(self->end(), values.begin(), values.end());
1195       }
1196 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){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (count < 0)
1200           throw std::out_of_range("count");
1201         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1202           throw std::invalid_argument("invalid range");
1203         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1204       }
1205 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){
1206         if (index>=0 && index<(int)self->size()+1)
1207           self->insert(self->begin()+index, x);
1208         else
1209           throw std::out_of_range("index");
1210       }
1211 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){
1212         if (index>=0 && index<(int)self->size()+1)
1213           self->insert(self->begin()+index, values.begin(), values.end());
1214         else
1215           throw std::out_of_range("index");
1216       }
1217 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){
1218         if (index>=0 && index<(int)self->size())
1219           self->erase(self->begin() + index);
1220         else
1221           throw std::out_of_range("index");
1222       }
1223 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){
1224         if (index < 0)
1225           throw std::out_of_range("index");
1226         if (count < 0)
1227           throw std::out_of_range("count");
1228         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1229           throw std::invalid_argument("invalid range");
1230         self->erase(self->begin()+index, self->begin()+index+count);
1231       }
1232 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){
1233         if (count < 0)
1234           throw std::out_of_range("count");
1235         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1236       }
1237 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){
1238         std::reverse(self->begin(), self->end());
1239       }
1240 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){
1241         if (index < 0)
1242           throw std::out_of_range("index");
1243         if (count < 0)
1244           throw std::out_of_range("count");
1245         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1246           throw std::invalid_argument("invalid range");
1247         std::reverse(self->begin()+index, self->begin()+index+count);
1248       }
1249 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){
1250         if (index < 0)
1251           throw std::out_of_range("index");
1252         if (index+values.size() > self->size())
1253           throw std::out_of_range("index");
1254         std::copy(values.begin(), values.end(), self->begin()+index);
1255       }
1256 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1257         std::vector< Dali::Actor >* pv = 0;
1258         if (capacity >= 0) {
1259           pv = new std::vector< Dali::Actor >();
1260           pv->reserve(capacity);
1261        } else {
1262           throw std::out_of_range("capacity");
1263        }
1264        return pv;
1265       }
1266 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1267         if (index>=0 && index<(int)self->size())
1268           return (*self)[index];
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1273         if (index>=0 && index<(int)self->size())
1274           return (*self)[index];
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1279         if (index>=0 && index<(int)self->size())
1280           (*self)[index] = val;
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1285         self->insert(self->end(), values.begin(), values.end());
1286       }
1287 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1297         if (index>=0 && index<(int)self->size()+1)
1298           self->insert(self->begin()+index, x);
1299         else
1300           throw std::out_of_range("index");
1301       }
1302 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1303         if (index>=0 && index<(int)self->size()+1)
1304           self->insert(self->begin()+index, values.begin(), values.end());
1305         else
1306           throw std::out_of_range("index");
1307       }
1308 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1309         if (index>=0 && index<(int)self->size())
1310           self->erase(self->begin() + index);
1311         else
1312           throw std::out_of_range("index");
1313       }
1314 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         self->erase(self->begin()+index, self->begin()+index+count);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1324         if (count < 0)
1325           throw std::out_of_range("count");
1326         return new std::vector< Dali::Actor >(count, value);
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1329         std::reverse(self->begin(), self->end());
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1332         if (index < 0)
1333           throw std::out_of_range("index");
1334         if (count < 0)
1335           throw std::out_of_range("count");
1336         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1337           throw std::invalid_argument("invalid range");
1338         std::reverse(self->begin()+index, self->begin()+index+count);
1339       }
1340 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1341         if (index < 0)
1342           throw std::out_of_range("index");
1343         if (index+values.size() > self->size())
1344           throw std::out_of_range("index");
1345         std::copy(values.begin(), values.end(), self->begin()+index);
1346       }
1347 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1348          return self->Empty();
1349       }
1350 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1351         return self->GetConnectionCount();
1352       }
1353 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 &)){
1354           self->Connect( func );
1355       }
1356 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 &)){
1357           self->Disconnect( func );
1358       }
1359 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){
1360           return self->Emit( arg );
1361       }
1362 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){
1363          return self->Empty();
1364       }
1365 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){
1366         return self->GetConnectionCount();
1367       }
1368 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 &)){
1369         self->Connect( func );
1370       }
1371 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 &)){
1372         self->Disconnect( func );
1373       }
1374 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){
1375         return self->Emit( arg1, arg2 );
1376       }
1377 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){
1378          return self->Empty();
1379       }
1380 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){
1381         return self->GetConnectionCount();
1382       }
1383 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)){
1384         self->Connect( func );
1385       }
1386 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)){
1387         self->Disconnect( func );
1388       }
1389 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){
1390         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1391 /*@SWIG@*/ self->Emit( arg1, arg2 );
1392       }
1393 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1394          return self->Empty();
1395       }
1396 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){
1397         return self->GetConnectionCount();
1398       }
1399 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)){
1400         self->Connect( func );
1401       }
1402 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)){
1403         self->Disconnect( func );
1404       }
1405 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){
1406         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1407 /*@SWIG@*/ self->Emit( arg1, arg2 );
1408       }
1409 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1410          return self->Empty();
1411       }
1412 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1413         return self->GetConnectionCount();
1414       }
1415 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)){
1416         self->Connect( func );
1417       }
1418 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)){
1419         self->Disconnect( func );
1420       }
1421 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){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 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){
1426          return self->Empty();
1427       }
1428 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){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432         self->Connect( func );
1433       }
1434 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)){
1435         self->Disconnect( func );
1436       }
1437 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){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448           self->Connect( func );
1449       }
1450 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)){
1451           self->Disconnect( func );
1452       }
1453 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1454           return self->Emit( arg );
1455       }
1456 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1457          return self->Empty();
1458       }
1459 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463           self->Connect( func );
1464       }
1465 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)){
1466           self->Disconnect( func );
1467       }
1468 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1469           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1470 /*@SWIG@*/ self->Emit( arg );
1471       }
1472 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){
1473          return self->Empty();
1474       }
1475 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){
1476         return self->GetConnectionCount();
1477       }
1478 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)){
1479           return self->Connect( func );
1480       }
1481 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)){
1482           self->Disconnect( func );
1483       }
1484 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){
1485           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1486 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 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)){
1495           self->Connect( func );
1496       }
1497 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)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 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){
1505          return self->Empty();
1506       }
1507 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){
1508         return self->GetConnectionCount();
1509       }
1510 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 &)){
1511           self->Connect( func );
1512       }
1513 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 &)){
1514           self->Disconnect( func );
1515       }
1516 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){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1521          return self->Empty();
1522       }
1523 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){
1524         return self->GetConnectionCount();
1525       }
1526 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 &)){
1527           self->Connect( func );
1528       }
1529 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 &)){
1530           self->Disconnect( func );
1531       }
1532 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){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 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)){
1559           self->Connect( func );
1560       }
1561 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)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 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){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575         self->Connect( func );
1576       }
1577 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 &)){
1578         self->Disconnect( func );
1579       }
1580 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){
1581         return self->Emit( arg1, arg2 );
1582       }
1583 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1584          return self->Empty();
1585       }
1586 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1587         return self->GetConnectionCount();
1588       }
1589 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)){
1590           self->Connect( func );
1591       }
1592 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)){
1593           self->Disconnect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1596           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1597 /*@SWIG@*/ self->Emit( arg );
1598       }
1599 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1600          return self->Empty();
1601       }
1602 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1603         return self->GetConnectionCount();
1604       }
1605 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 &)){
1606           self->Connect( func );
1607       }
1608 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 &)){
1609           self->Disconnect( func );
1610       }
1611 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){
1612           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1613 /*@SWIG@*/ self->Emit( arg );
1614       }
1615 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1616          return self->Empty();
1617       }
1618 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){
1619         return self->GetConnectionCount();
1620       }
1621 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)){
1622         self->Connect( func );
1623       }
1624 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)){
1625         self->Disconnect( func );
1626       }
1627 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){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1631          return self->Empty();
1632       }
1633 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){
1634         return self->GetConnectionCount();
1635       }
1636 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)){
1637         self->Connect( func );
1638       }
1639 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)){
1640         self->Disconnect( func );
1641       }
1642 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){
1643         return self->Emit( arg1, arg2 );
1644       }
1645
1646
1647 /* ---------------------------------------------------
1648  * C++ director class methods
1649  * --------------------------------------------------- */
1650
1651 #include "dali_wrap.h"
1652
1653 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1654   swig_init_callbacks();
1655 }
1656
1657 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1658
1659 }
1660
1661
1662 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1663   int jdepth  ;
1664
1665   if (!swig_callbackOnStageConnection) {
1666     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1667     return;
1668   } else {
1669     jdepth = depth;
1670     swig_callbackOnStageConnection(jdepth);
1671   }
1672 }
1673
1674 void SwigDirector_ViewImpl::OnStageDisconnection() {
1675   if (!swig_callbackOnStageDisconnection) {
1676     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1677     return;
1678   } else {
1679     swig_callbackOnStageDisconnection();
1680   }
1681 }
1682
1683 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1684   void * jchild = 0 ;
1685
1686   if (!swig_callbackOnChildAdd) {
1687     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1688     return;
1689   } else {
1690     jchild = (Dali::Actor *) &child;
1691     swig_callbackOnChildAdd(jchild);
1692   }
1693 }
1694
1695 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1696   void * jchild = 0 ;
1697
1698   if (!swig_callbackOnChildRemove) {
1699     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1700     return;
1701   } else {
1702     jchild = (Dali::Actor *) &child;
1703     swig_callbackOnChildRemove(jchild);
1704   }
1705 }
1706
1707 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1708   int jindex  ;
1709   void * jpropertyValue  ;
1710
1711   if (!swig_callbackOnPropertySet) {
1712     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1713     return;
1714   } else {
1715     jindex = index;
1716     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1717     swig_callbackOnPropertySet(jindex, jpropertyValue);
1718   }
1719 }
1720
1721 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1722   void * jtargetSize = 0 ;
1723
1724   if (!swig_callbackOnSizeSet) {
1725     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1726     return;
1727   } else {
1728     jtargetSize = (Dali::Vector3 *) &targetSize;
1729     swig_callbackOnSizeSet(jtargetSize);
1730   }
1731 }
1732
1733 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1734   void * janimation = 0 ;
1735   void * jtargetSize = 0 ;
1736
1737   if (!swig_callbackOnSizeAnimation) {
1738     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1739     return;
1740   } else {
1741     janimation = (Dali::Animation *) &animation;
1742     jtargetSize = (Dali::Vector3 *) &targetSize;
1743     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1744   }
1745 }
1746
1747 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1748   bool c_result = SwigValueInit< bool >() ;
1749   unsigned int jresult = 0 ;
1750   void * jarg0 = 0 ;
1751
1752   if (!swig_callbackOnTouchEvent) {
1753     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1754   } else {
1755     jarg0 = (Dali::TouchEvent *) &event;
1756     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1757     c_result = jresult ? true : false;
1758   }
1759   return c_result;
1760 }
1761
1762 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1763   bool c_result = SwigValueInit< bool >() ;
1764   unsigned int jresult = 0 ;
1765   void * jarg0 = 0 ;
1766
1767   if (!swig_callbackOnHoverEvent) {
1768     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1769   } else {
1770     jarg0 = (Dali::HoverEvent *) &event;
1771     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1772     c_result = jresult ? true : false;
1773   }
1774   return c_result;
1775 }
1776
1777 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1778   bool c_result = SwigValueInit< bool >() ;
1779   unsigned int jresult = 0 ;
1780   void * jarg0 = 0 ;
1781
1782   if (!swig_callbackOnKeyEvent) {
1783     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1784   } else {
1785     jarg0 = (Dali::KeyEvent *) &event;
1786     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1787     c_result = jresult ? true : false;
1788   }
1789   return c_result;
1790 }
1791
1792 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1793   bool c_result = SwigValueInit< bool >() ;
1794   unsigned int jresult = 0 ;
1795   void * jarg0 = 0 ;
1796
1797   if (!swig_callbackOnWheelEvent) {
1798     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1799   } else {
1800     jarg0 = (Dali::WheelEvent *) &event;
1801     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1802     c_result = jresult ? true : false;
1803   }
1804   return c_result;
1805 }
1806
1807 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1808   void * jsize = 0 ;
1809   void * jcontainer = 0 ;
1810
1811   if (!swig_callbackOnRelayout) {
1812     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1813     return;
1814   } else {
1815     jsize = (Dali::Vector2 *) &size;
1816     jcontainer = (Dali::RelayoutContainer *) &container;
1817     swig_callbackOnRelayout(jsize, jcontainer);
1818   }
1819 }
1820
1821 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1822   int jpolicy  ;
1823   int jdimension  ;
1824
1825   if (!swig_callbackOnSetResizePolicy) {
1826     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1827     return;
1828   } else {
1829     jpolicy = (int)policy;
1830     jdimension = (int)dimension;
1831     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1832   }
1833 }
1834
1835 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1836   Dali::Vector3 c_result ;
1837   void * jresult = 0 ;
1838
1839   if (!swig_callbackGetNaturalSize) {
1840     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1841   } else {
1842     jresult = (void *) swig_callbackGetNaturalSize();
1843     if (!jresult) {
1844       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1845       return c_result;
1846     }
1847     c_result = *(Dali::Vector3 *)jresult;
1848   }
1849   return c_result;
1850 }
1851
1852 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1853   float c_result = SwigValueInit< float >() ;
1854   float jresult = 0 ;
1855   void * jchild = 0 ;
1856   int jdimension  ;
1857
1858   if (!swig_callbackCalculateChildSize) {
1859     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1860   } else {
1861     jchild = (Dali::Actor *) &child;
1862     jdimension = (int)dimension;
1863     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1864     c_result = (float)jresult;
1865   }
1866   return c_result;
1867 }
1868
1869 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1870   float c_result = SwigValueInit< float >() ;
1871   float jresult = 0 ;
1872   float jwidth  ;
1873
1874   if (!swig_callbackGetHeightForWidth) {
1875     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1876   } else {
1877     jwidth = width;
1878     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1879     c_result = (float)jresult;
1880   }
1881   return c_result;
1882 }
1883
1884 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1885   float c_result = SwigValueInit< float >() ;
1886   float jresult = 0 ;
1887   float jheight  ;
1888
1889   if (!swig_callbackGetWidthForHeight) {
1890     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1891   } else {
1892     jheight = height;
1893     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1894     c_result = (float)jresult;
1895   }
1896   return c_result;
1897 }
1898
1899 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1900   bool c_result = SwigValueInit< bool >() ;
1901   unsigned int jresult = 0 ;
1902   int jdimension  ;
1903
1904   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1905     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1906   } else {
1907     jdimension = (int)dimension;
1908     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1909     c_result = jresult ? true : false;
1910   }
1911   return c_result;
1912 }
1913
1914 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1915   int jdimension  ;
1916
1917   if (!swig_callbackOnCalculateRelayoutSize) {
1918     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1919     return;
1920   } else {
1921     jdimension = (int)dimension;
1922     swig_callbackOnCalculateRelayoutSize(jdimension);
1923   }
1924 }
1925
1926 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1927   float jsize  ;
1928   int jdimension  ;
1929
1930   if (!swig_callbackOnLayoutNegotiated) {
1931     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1932     return;
1933   } else {
1934     jsize = size;
1935     jdimension = (int)dimension;
1936     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1937   }
1938 }
1939
1940 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1941   return Dali::CustomActorImpl::GetExtension();
1942 }
1943
1944 void SwigDirector_ViewImpl::OnInitialize() {
1945   if (!swig_callbackOnInitialize) {
1946     Dali::Toolkit::Internal::Control::OnInitialize();
1947     return;
1948   } else {
1949     swig_callbackOnInitialize();
1950   }
1951 }
1952
1953 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1954   void * jchild = 0 ;
1955
1956   if (!swig_callbackOnControlChildAdd) {
1957     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1958     return;
1959   } else {
1960     jchild = (Dali::Actor *) &child;
1961     swig_callbackOnControlChildAdd(jchild);
1962   }
1963 }
1964
1965 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1966   void * jchild = 0 ;
1967
1968   if (!swig_callbackOnControlChildRemove) {
1969     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1970     return;
1971   } else {
1972     jchild = (Dali::Actor *) &child;
1973     swig_callbackOnControlChildRemove(jchild);
1974   }
1975 }
1976
1977 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1978   void * jstyleManager  ;
1979   int jchange  ;
1980
1981   if (!swig_callbackOnStyleChange) {
1982     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1983     return;
1984   } else {
1985     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1986     jchange = (int)change;
1987     swig_callbackOnStyleChange(jstyleManager, jchange);
1988   }
1989 }
1990
1991 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1992   bool c_result = SwigValueInit< bool >() ;
1993   unsigned int jresult = 0 ;
1994
1995   if (!swig_callbackOnAccessibilityActivated) {
1996     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1997   } else {
1998     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1999     c_result = jresult ? true : false;
2000   }
2001   return c_result;
2002 }
2003
2004 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2005   bool c_result = SwigValueInit< bool >() ;
2006   unsigned int jresult = 0 ;
2007   void * jgesture  ;
2008
2009   if (!swig_callbackOnAccessibilityPan) {
2010     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2011   } else {
2012     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2013     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2014     c_result = jresult ? true : false;
2015   }
2016   return c_result;
2017 }
2018
2019 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2020   bool c_result = SwigValueInit< bool >() ;
2021   unsigned int jresult = 0 ;
2022   void * jtouchEvent = 0 ;
2023
2024   if (!swig_callbackOnAccessibilityTouch) {
2025     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2026   } else {
2027     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2028     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2029     c_result = jresult ? true : false;
2030   }
2031   return c_result;
2032 }
2033
2034 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2035   bool c_result = SwigValueInit< bool >() ;
2036   unsigned int jresult = 0 ;
2037   unsigned int jisIncrease  ;
2038
2039   if (!swig_callbackOnAccessibilityValueChange) {
2040     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2041   } else {
2042     jisIncrease = isIncrease;
2043     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2044     c_result = jresult ? true : false;
2045   }
2046   return c_result;
2047 }
2048
2049 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2050   bool c_result = SwigValueInit< bool >() ;
2051   unsigned int jresult = 0 ;
2052
2053   if (!swig_callbackOnAccessibilityZoom) {
2054     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2055   } else {
2056     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2057     c_result = jresult ? true : false;
2058   }
2059   return c_result;
2060 }
2061
2062 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2063   if (!swig_callbackOnKeyInputFocusGained) {
2064     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2065     return;
2066   } else {
2067     swig_callbackOnKeyInputFocusGained();
2068   }
2069 }
2070
2071 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2072   if (!swig_callbackOnKeyInputFocusLost) {
2073     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2074     return;
2075   } else {
2076     swig_callbackOnKeyInputFocusLost();
2077   }
2078 }
2079
2080 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2081   Dali::Actor c_result ;
2082   void * jresult = 0 ;
2083   void * jcurrentFocusedActor  ;
2084   int jdirection  ;
2085   unsigned int jloopEnabled  ;
2086
2087   if (!swig_callbackGetNextKeyboardFocusableActor) {
2088     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2089   } else {
2090     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2091     jdirection = (int)direction;
2092     jloopEnabled = loopEnabled;
2093     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2094     if (!jresult) {
2095       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2096       return c_result;
2097     }
2098     c_result = *(Dali::Actor *)jresult;
2099   }
2100   return c_result;
2101 }
2102
2103 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2104   void * jcommitedFocusableActor  ;
2105
2106   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2107     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2108     return;
2109   } else {
2110     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2111     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2112   }
2113 }
2114
2115 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2116   bool c_result = SwigValueInit< bool >() ;
2117   unsigned int jresult = 0 ;
2118
2119   if (!swig_callbackOnKeyboardEnter) {
2120     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2121   } else {
2122     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2123     c_result = jresult ? true : false;
2124   }
2125   return c_result;
2126 }
2127
2128 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2129   void * jpinch = 0 ;
2130
2131   if (!swig_callbackOnPinch) {
2132     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2133     return;
2134   } else {
2135     jpinch = (Dali::PinchGesture *) &pinch;
2136     swig_callbackOnPinch(jpinch);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2141   void * jpan = 0 ;
2142
2143   if (!swig_callbackOnPan) {
2144     Dali::Toolkit::Internal::Control::OnPan(pan);
2145     return;
2146   } else {
2147     jpan = (Dali::PanGesture *) &pan;
2148     swig_callbackOnPan(jpan);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2153   void * jtap = 0 ;
2154
2155   if (!swig_callbackOnTap) {
2156     Dali::Toolkit::Internal::Control::OnTap(tap);
2157     return;
2158   } else {
2159     jtap = (Dali::TapGesture *) &tap;
2160     swig_callbackOnTap(jtap);
2161   }
2162 }
2163
2164 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2165   void * jlongPress = 0 ;
2166
2167   if (!swig_callbackOnLongPress) {
2168     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2169     return;
2170   } else {
2171     jlongPress = (Dali::LongPressGesture *) &longPress;
2172     swig_callbackOnLongPress(jlongPress);
2173   }
2174 }
2175
2176 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2177   void * jslotObserver = 0 ;
2178   void * jcallback = 0 ;
2179
2180   if (!swig_callbackSignalConnected) {
2181     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2182     return;
2183   } else {
2184     jslotObserver = (void *) slotObserver;
2185     jcallback = (void *) callback;
2186     swig_callbackSignalConnected(jslotObserver, jcallback);
2187   }
2188 }
2189
2190 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2191   void * jslotObserver = 0 ;
2192   void * jcallback = 0 ;
2193
2194   if (!swig_callbackSignalDisconnected) {
2195     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2196     return;
2197   } else {
2198     jslotObserver = (void *) slotObserver;
2199     jcallback = (void *) callback;
2200     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2201   }
2202 }
2203
2204 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2205   return Dali::Toolkit::Internal::Control::GetControlExtension();
2206 }
2207
2208 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) {
2209   swig_callbackOnStageConnection = callbackOnStageConnection;
2210   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2211   swig_callbackOnChildAdd = callbackOnChildAdd;
2212   swig_callbackOnChildRemove = callbackOnChildRemove;
2213   swig_callbackOnPropertySet = callbackOnPropertySet;
2214   swig_callbackOnSizeSet = callbackOnSizeSet;
2215   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2216   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2217   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2218   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2219   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2220   swig_callbackOnRelayout = callbackOnRelayout;
2221   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2222   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2223   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2224   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2225   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2226   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2227   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2228   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2229   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2230   swig_callbackOnInitialize = callbackOnInitialize;
2231   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2232   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2233   swig_callbackOnStyleChange = callbackOnStyleChange;
2234   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2235   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2236   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2237   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2238   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2239   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2240   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2241   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2242   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2243   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2244   swig_callbackOnPinch = callbackOnPinch;
2245   swig_callbackOnPan = callbackOnPan;
2246   swig_callbackOnTap = callbackOnTap;
2247   swig_callbackOnLongPress = callbackOnLongPress;
2248   swig_callbackSignalConnected = callbackSignalConnected;
2249   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2250 }
2251
2252 void SwigDirector_ViewImpl::swig_init_callbacks() {
2253   swig_callbackOnStageConnection = 0;
2254   swig_callbackOnStageDisconnection = 0;
2255   swig_callbackOnChildAdd = 0;
2256   swig_callbackOnChildRemove = 0;
2257   swig_callbackOnPropertySet = 0;
2258   swig_callbackOnSizeSet = 0;
2259   swig_callbackOnSizeAnimation = 0;
2260   swig_callbackOnTouchEvent = 0;
2261   swig_callbackOnHoverEvent = 0;
2262   swig_callbackOnKeyEvent = 0;
2263   swig_callbackOnWheelEvent = 0;
2264   swig_callbackOnRelayout = 0;
2265   swig_callbackOnSetResizePolicy = 0;
2266   swig_callbackGetNaturalSize = 0;
2267   swig_callbackCalculateChildSize = 0;
2268   swig_callbackGetHeightForWidth = 0;
2269   swig_callbackGetWidthForHeight = 0;
2270   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2271   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2272   swig_callbackOnCalculateRelayoutSize = 0;
2273   swig_callbackOnLayoutNegotiated = 0;
2274   swig_callbackOnInitialize = 0;
2275   swig_callbackOnControlChildAdd = 0;
2276   swig_callbackOnControlChildRemove = 0;
2277   swig_callbackOnStyleChange = 0;
2278   swig_callbackOnAccessibilityActivated = 0;
2279   swig_callbackOnAccessibilityPan = 0;
2280   swig_callbackOnAccessibilityTouch = 0;
2281   swig_callbackOnAccessibilityValueChange = 0;
2282   swig_callbackOnAccessibilityZoom = 0;
2283   swig_callbackOnKeyInputFocusGained = 0;
2284   swig_callbackOnKeyInputFocusLost = 0;
2285   swig_callbackGetNextKeyboardFocusableActor = 0;
2286   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2287   swig_callbackOnKeyboardEnter = 0;
2288   swig_callbackOnPinch = 0;
2289   swig_callbackOnPan = 0;
2290   swig_callbackOnTap = 0;
2291   swig_callbackOnLongPress = 0;
2292   swig_callbackSignalConnected = 0;
2293   swig_callbackSignalDisconnected = 0;
2294 }
2295
2296
2297 #ifdef __cplusplus
2298 extern "C" {
2299 #endif
2300
2301 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_floatp() {
2302   void * jresult ;
2303   floatp *result = 0 ;
2304
2305   {
2306     try {
2307       result = (floatp *)new_floatp();
2308     } catch (std::out_of_range& e) {
2309       {
2310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2311       };
2312     } catch (std::exception& e) {
2313       {
2314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2315       };
2316     } catch (...) {
2317       {
2318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2319       };
2320     }
2321   }
2322   jresult = (void *)result;
2323   return jresult;
2324 }
2325
2326
2327 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_floatp(void * jarg1) {
2328   floatp *arg1 = (floatp *) 0 ;
2329
2330   arg1 = (floatp *)jarg1;
2331   {
2332     try {
2333       delete_floatp(arg1);
2334     } catch (std::out_of_range& e) {
2335       {
2336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2337       };
2338     } catch (std::exception& e) {
2339       {
2340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2341       };
2342     } catch (...) {
2343       {
2344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2345       };
2346     }
2347   }
2348 }
2349
2350
2351 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_floatp_assign(void * jarg1, float jarg2) {
2352   floatp *arg1 = (floatp *) 0 ;
2353   float arg2 ;
2354
2355   arg1 = (floatp *)jarg1;
2356   arg2 = (float)jarg2;
2357   {
2358     try {
2359       floatp_assign(arg1,arg2);
2360     } catch (std::out_of_range& e) {
2361       {
2362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2363       };
2364     } catch (std::exception& e) {
2365       {
2366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2367       };
2368     } catch (...) {
2369       {
2370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2371       };
2372     }
2373   }
2374 }
2375
2376
2377 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_floatp_value(void * jarg1) {
2378   float jresult ;
2379   floatp *arg1 = (floatp *) 0 ;
2380   float result;
2381
2382   arg1 = (floatp *)jarg1;
2383   {
2384     try {
2385       result = (float)floatp_value(arg1);
2386     } catch (std::out_of_range& e) {
2387       {
2388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2389       };
2390     } catch (std::exception& e) {
2391       {
2392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2393       };
2394     } catch (...) {
2395       {
2396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2397       };
2398     }
2399   }
2400   jresult = result;
2401   return jresult;
2402 }
2403
2404
2405 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_floatp_cast(void * jarg1) {
2406   void * jresult ;
2407   floatp *arg1 = (floatp *) 0 ;
2408   float *result = 0 ;
2409
2410   arg1 = (floatp *)jarg1;
2411   {
2412     try {
2413       result = (float *)floatp_cast(arg1);
2414     } catch (std::out_of_range& e) {
2415       {
2416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2417       };
2418     } catch (std::exception& e) {
2419       {
2420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2421       };
2422     } catch (...) {
2423       {
2424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2425       };
2426     }
2427   }
2428   jresult = (void *)result;
2429   return jresult;
2430 }
2431
2432
2433 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_floatp_frompointer(void * jarg1) {
2434   void * jresult ;
2435   float *arg1 = (float *) 0 ;
2436   floatp *result = 0 ;
2437
2438   arg1 = (float *)jarg1;
2439   {
2440     try {
2441       result = (floatp *)floatp_frompointer(arg1);
2442     } catch (std::out_of_range& e) {
2443       {
2444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2445       };
2446     } catch (std::exception& e) {
2447       {
2448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2449       };
2450     } catch (...) {
2451       {
2452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2453       };
2454     }
2455   }
2456   jresult = (void *)result;
2457   return jresult;
2458 }
2459
2460
2461 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_intp() {
2462   void * jresult ;
2463   intp *result = 0 ;
2464
2465   {
2466     try {
2467       result = (intp *)new_intp();
2468     } catch (std::out_of_range& e) {
2469       {
2470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2471       };
2472     } catch (std::exception& e) {
2473       {
2474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2475       };
2476     } catch (...) {
2477       {
2478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2479       };
2480     }
2481   }
2482   jresult = (void *)result;
2483   return jresult;
2484 }
2485
2486
2487 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_intp(void * jarg1) {
2488   intp *arg1 = (intp *) 0 ;
2489
2490   arg1 = (intp *)jarg1;
2491   {
2492     try {
2493       delete_intp(arg1);
2494     } catch (std::out_of_range& e) {
2495       {
2496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2497       };
2498     } catch (std::exception& e) {
2499       {
2500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2501       };
2502     } catch (...) {
2503       {
2504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2505       };
2506     }
2507   }
2508 }
2509
2510
2511 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_intp_assign(void * jarg1, int jarg2) {
2512   intp *arg1 = (intp *) 0 ;
2513   int arg2 ;
2514
2515   arg1 = (intp *)jarg1;
2516   arg2 = (int)jarg2;
2517   {
2518     try {
2519       intp_assign(arg1,arg2);
2520     } catch (std::out_of_range& e) {
2521       {
2522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2523       };
2524     } catch (std::exception& e) {
2525       {
2526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2527       };
2528     } catch (...) {
2529       {
2530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2531       };
2532     }
2533   }
2534 }
2535
2536
2537 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_intp_value(void * jarg1) {
2538   int jresult ;
2539   intp *arg1 = (intp *) 0 ;
2540   int result;
2541
2542   arg1 = (intp *)jarg1;
2543   {
2544     try {
2545       result = (int)intp_value(arg1);
2546     } catch (std::out_of_range& e) {
2547       {
2548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2549       };
2550     } catch (std::exception& e) {
2551       {
2552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2553       };
2554     } catch (...) {
2555       {
2556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2557       };
2558     }
2559   }
2560   jresult = result;
2561   return jresult;
2562 }
2563
2564
2565 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_intp_cast(void * jarg1) {
2566   void * jresult ;
2567   intp *arg1 = (intp *) 0 ;
2568   int *result = 0 ;
2569
2570   arg1 = (intp *)jarg1;
2571   {
2572     try {
2573       result = (int *)intp_cast(arg1);
2574     } catch (std::out_of_range& e) {
2575       {
2576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2577       };
2578     } catch (std::exception& e) {
2579       {
2580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2581       };
2582     } catch (...) {
2583       {
2584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2585       };
2586     }
2587   }
2588   jresult = (void *)result;
2589   return jresult;
2590 }
2591
2592
2593 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_intp_frompointer(void * jarg1) {
2594   void * jresult ;
2595   int *arg1 = (int *) 0 ;
2596   intp *result = 0 ;
2597
2598   arg1 = (int *)jarg1;
2599   {
2600     try {
2601       result = (intp *)intp_frompointer(arg1);
2602     } catch (std::out_of_range& e) {
2603       {
2604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2605       };
2606     } catch (std::exception& e) {
2607       {
2608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2609       };
2610     } catch (...) {
2611       {
2612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2613       };
2614     }
2615   }
2616   jresult = (void *)result;
2617   return jresult;
2618 }
2619
2620
2621 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_doublep() {
2622   void * jresult ;
2623   doublep *result = 0 ;
2624
2625   {
2626     try {
2627       result = (doublep *)new_doublep();
2628     } catch (std::out_of_range& e) {
2629       {
2630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (std::exception& e) {
2633       {
2634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2635       };
2636     } catch (...) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2639       };
2640     }
2641   }
2642   jresult = (void *)result;
2643   return jresult;
2644 }
2645
2646
2647 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_doublep(void * jarg1) {
2648   doublep *arg1 = (doublep *) 0 ;
2649
2650   arg1 = (doublep *)jarg1;
2651   {
2652     try {
2653       delete_doublep(arg1);
2654     } catch (std::out_of_range& e) {
2655       {
2656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2657       };
2658     } catch (std::exception& e) {
2659       {
2660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (...) {
2663       {
2664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2665       };
2666     }
2667   }
2668 }
2669
2670
2671 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_doublep_assign(void * jarg1, double jarg2) {
2672   doublep *arg1 = (doublep *) 0 ;
2673   double arg2 ;
2674
2675   arg1 = (doublep *)jarg1;
2676   arg2 = (double)jarg2;
2677   {
2678     try {
2679       doublep_assign(arg1,arg2);
2680     } catch (std::out_of_range& e) {
2681       {
2682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (std::exception& e) {
2685       {
2686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2687       };
2688     } catch (...) {
2689       {
2690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2691       };
2692     }
2693   }
2694 }
2695
2696
2697 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_doublep_value(void * jarg1) {
2698   double jresult ;
2699   doublep *arg1 = (doublep *) 0 ;
2700   double result;
2701
2702   arg1 = (doublep *)jarg1;
2703   {
2704     try {
2705       result = (double)doublep_value(arg1);
2706     } catch (std::out_of_range& e) {
2707       {
2708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2709       };
2710     } catch (std::exception& e) {
2711       {
2712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (...) {
2715       {
2716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2717       };
2718     }
2719   }
2720   jresult = result;
2721   return jresult;
2722 }
2723
2724
2725 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_doublep_cast(void * jarg1) {
2726   void * jresult ;
2727   doublep *arg1 = (doublep *) 0 ;
2728   double *result = 0 ;
2729
2730   arg1 = (doublep *)jarg1;
2731   {
2732     try {
2733       result = (double *)doublep_cast(arg1);
2734     } catch (std::out_of_range& e) {
2735       {
2736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2737       };
2738     } catch (std::exception& e) {
2739       {
2740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2741       };
2742     } catch (...) {
2743       {
2744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2745       };
2746     }
2747   }
2748   jresult = (void *)result;
2749   return jresult;
2750 }
2751
2752
2753 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_doublep_frompointer(void * jarg1) {
2754   void * jresult ;
2755   double *arg1 = (double *) 0 ;
2756   doublep *result = 0 ;
2757
2758   arg1 = (double *)jarg1;
2759   {
2760     try {
2761       result = (doublep *)doublep_frompointer(arg1);
2762     } catch (std::out_of_range& e) {
2763       {
2764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2765       };
2766     } catch (std::exception& e) {
2767       {
2768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2769       };
2770     } catch (...) {
2771       {
2772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2773       };
2774     }
2775   }
2776   jresult = (void *)result;
2777   return jresult;
2778 }
2779
2780
2781 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_uintp() {
2782   void * jresult ;
2783   uintp *result = 0 ;
2784
2785   {
2786     try {
2787       result = (uintp *)new_uintp();
2788     } catch (std::out_of_range& e) {
2789       {
2790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (std::exception& e) {
2793       {
2794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802   jresult = (void *)result;
2803   return jresult;
2804 }
2805
2806
2807 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_uintp(void * jarg1) {
2808   uintp *arg1 = (uintp *) 0 ;
2809
2810   arg1 = (uintp *)jarg1;
2811   {
2812     try {
2813       delete_uintp(arg1);
2814     } catch (std::out_of_range& e) {
2815       {
2816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2817       };
2818     } catch (std::exception& e) {
2819       {
2820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (...) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2825       };
2826     }
2827   }
2828 }
2829
2830
2831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_uintp_assign(void * jarg1, unsigned int jarg2) {
2832   uintp *arg1 = (uintp *) 0 ;
2833   unsigned int arg2 ;
2834
2835   arg1 = (uintp *)jarg1;
2836   arg2 = (unsigned int)jarg2;
2837   {
2838     try {
2839       uintp_assign(arg1,arg2);
2840     } catch (std::out_of_range& e) {
2841       {
2842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (std::exception& e) {
2845       {
2846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2847       };
2848     } catch (...) {
2849       {
2850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2851       };
2852     }
2853   }
2854 }
2855
2856
2857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_uintp_value(void * jarg1) {
2858   unsigned int jresult ;
2859   uintp *arg1 = (uintp *) 0 ;
2860   unsigned int result;
2861
2862   arg1 = (uintp *)jarg1;
2863   {
2864     try {
2865       result = (unsigned int)uintp_value(arg1);
2866     } catch (std::out_of_range& e) {
2867       {
2868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2869       };
2870     } catch (std::exception& e) {
2871       {
2872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2873       };
2874     } catch (...) {
2875       {
2876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2877       };
2878     }
2879   }
2880   jresult = result;
2881   return jresult;
2882 }
2883
2884
2885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_uintp_cast(void * jarg1) {
2886   void * jresult ;
2887   uintp *arg1 = (uintp *) 0 ;
2888   unsigned int *result = 0 ;
2889
2890   arg1 = (uintp *)jarg1;
2891   {
2892     try {
2893       result = (unsigned int *)uintp_cast(arg1);
2894     } catch (std::out_of_range& e) {
2895       {
2896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2897       };
2898     } catch (std::exception& e) {
2899       {
2900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2901       };
2902     } catch (...) {
2903       {
2904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2905       };
2906     }
2907   }
2908   jresult = (void *)result;
2909   return jresult;
2910 }
2911
2912
2913 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_uintp_frompointer(void * jarg1) {
2914   void * jresult ;
2915   unsigned int *arg1 = (unsigned int *) 0 ;
2916   uintp *result = 0 ;
2917
2918   arg1 = (unsigned int *)jarg1;
2919   {
2920     try {
2921       result = (uintp *)uintp_frompointer(arg1);
2922     } catch (std::out_of_range& e) {
2923       {
2924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2925       };
2926     } catch (std::exception& e) {
2927       {
2928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2929       };
2930     } catch (...) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2933       };
2934     }
2935   }
2936   jresult = (void *)result;
2937   return jresult;
2938 }
2939
2940
2941 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ushortp() {
2942   void * jresult ;
2943   ushortp *result = 0 ;
2944
2945   {
2946     try {
2947       result = (ushortp *)new_ushortp();
2948     } catch (std::out_of_range& e) {
2949       {
2950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (std::exception& e) {
2953       {
2954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962   jresult = (void *)result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ushortp(void * jarg1) {
2968   ushortp *arg1 = (ushortp *) 0 ;
2969
2970   arg1 = (ushortp *)jarg1;
2971   {
2972     try {
2973       delete_ushortp(arg1);
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2981       };
2982     } catch (...) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2985       };
2986     }
2987   }
2988 }
2989
2990
2991 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ushortp_assign(void * jarg1, unsigned short jarg2) {
2992   ushortp *arg1 = (ushortp *) 0 ;
2993   unsigned short arg2 ;
2994
2995   arg1 = (ushortp *)jarg1;
2996   arg2 = (unsigned short)jarg2;
2997   {
2998     try {
2999       ushortp_assign(arg1,arg2);
3000     } catch (std::out_of_range& e) {
3001       {
3002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (std::exception& e) {
3005       {
3006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3007       };
3008     } catch (...) {
3009       {
3010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3011       };
3012     }
3013   }
3014 }
3015
3016
3017 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_ushortp_value(void * jarg1) {
3018   unsigned short jresult ;
3019   ushortp *arg1 = (ushortp *) 0 ;
3020   unsigned short result;
3021
3022   arg1 = (ushortp *)jarg1;
3023   {
3024     try {
3025       result = (unsigned short)ushortp_value(arg1);
3026     } catch (std::out_of_range& e) {
3027       {
3028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3029       };
3030     } catch (std::exception& e) {
3031       {
3032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3033       };
3034     } catch (...) {
3035       {
3036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3037       };
3038     }
3039   }
3040   jresult = result;
3041   return jresult;
3042 }
3043
3044
3045 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ushortp_cast(void * jarg1) {
3046   void * jresult ;
3047   ushortp *arg1 = (ushortp *) 0 ;
3048   unsigned short *result = 0 ;
3049
3050   arg1 = (ushortp *)jarg1;
3051   {
3052     try {
3053       result = (unsigned short *)ushortp_cast(arg1);
3054     } catch (std::out_of_range& e) {
3055       {
3056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3057       };
3058     } catch (std::exception& e) {
3059       {
3060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3061       };
3062     } catch (...) {
3063       {
3064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3065       };
3066     }
3067   }
3068   jresult = (void *)result;
3069   return jresult;
3070 }
3071
3072
3073 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ushortp_frompointer(void * jarg1) {
3074   void * jresult ;
3075   unsigned short *arg1 = (unsigned short *) 0 ;
3076   ushortp *result = 0 ;
3077
3078   arg1 = (unsigned short *)jarg1;
3079   {
3080     try {
3081       result = (ushortp *)ushortp_frompointer(arg1);
3082     } catch (std::out_of_range& e) {
3083       {
3084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3085       };
3086     } catch (std::exception& e) {
3087       {
3088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3089       };
3090     } catch (...) {
3091       {
3092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3093       };
3094     }
3095   }
3096   jresult = (void *)result;
3097   return jresult;
3098 }
3099
3100
3101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_int_to_uint(int jarg1) {
3102   unsigned int jresult ;
3103   int arg1 ;
3104   unsigned int result;
3105
3106   arg1 = (int)jarg1;
3107   {
3108     try {
3109       result = (unsigned int)int_to_uint(arg1);
3110     } catch (std::out_of_range& e) {
3111       {
3112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (std::exception& e) {
3115       {
3116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3117       };
3118     } catch (...) {
3119       {
3120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3121       };
3122     }
3123   }
3124   jresult = result;
3125   return jresult;
3126 }
3127
3128
3129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RefObject_Reference(void * jarg1) {
3130   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3131
3132   arg1 = (Dali::RefObject *)jarg1;
3133   {
3134     try {
3135       (arg1)->Reference();
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3147       };
3148     }
3149   }
3150 }
3151
3152
3153 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RefObject_Unreference(void * jarg1) {
3154   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3155
3156   arg1 = (Dali::RefObject *)jarg1;
3157   {
3158     try {
3159       (arg1)->Unreference();
3160     } catch (std::out_of_range& e) {
3161       {
3162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3163       };
3164     } catch (std::exception& e) {
3165       {
3166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3167       };
3168     } catch (...) {
3169       {
3170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3171       };
3172     }
3173   }
3174 }
3175
3176
3177 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RefObject_ReferenceCount(void * jarg1) {
3178   int jresult ;
3179   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3180   int result;
3181
3182   arg1 = (Dali::RefObject *)jarg1;
3183   {
3184     try {
3185       result = (int)(arg1)->ReferenceCount();
3186     } catch (std::out_of_range& e) {
3187       {
3188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3189       };
3190     } catch (std::exception& e) {
3191       {
3192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3193       };
3194     } catch (...) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3197       };
3198     }
3199   }
3200   jresult = result;
3201   return jresult;
3202 }
3203
3204
3205 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any__SWIG_0() {
3206   void * jresult ;
3207   Dali::Any *result = 0 ;
3208
3209   {
3210     try {
3211       result = (Dali::Any *)new Dali::Any();
3212     } catch (std::out_of_range& e) {
3213       {
3214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (std::exception& e) {
3217       {
3218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3219       };
3220     } catch (...) {
3221       {
3222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3223       };
3224     }
3225   }
3226   jresult = (void *)result;
3227   return jresult;
3228 }
3229
3230
3231 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Any(void * jarg1) {
3232   Dali::Any *arg1 = (Dali::Any *) 0 ;
3233
3234   arg1 = (Dali::Any *)jarg1;
3235   {
3236     try {
3237       delete arg1;
3238     } catch (std::out_of_range& e) {
3239       {
3240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3241       };
3242     } catch (std::exception& e) {
3243       {
3244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3245       };
3246     } catch (...) {
3247       {
3248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3249       };
3250     }
3251   }
3252 }
3253
3254
3255 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AssertAlways(char * jarg1) {
3256   char *arg1 = (char *) 0 ;
3257
3258   arg1 = (char *)jarg1;
3259   {
3260     try {
3261       Dali::Any::AssertAlways((char const *)arg1);
3262     } catch (std::out_of_range& e) {
3263       {
3264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3265       };
3266     } catch (std::exception& e) {
3267       {
3268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3273       };
3274     }
3275   }
3276 }
3277
3278
3279 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any__SWIG_2(void * jarg1) {
3280   void * jresult ;
3281   Dali::Any *arg1 = 0 ;
3282   Dali::Any *result = 0 ;
3283
3284   arg1 = (Dali::Any *)jarg1;
3285   if (!arg1) {
3286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3287     return 0;
3288   }
3289   {
3290     try {
3291       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_Assign(void * jarg1, void * jarg2) {
3312   void * jresult ;
3313   Dali::Any *arg1 = (Dali::Any *) 0 ;
3314   Dali::Any *arg2 = 0 ;
3315   Dali::Any *result = 0 ;
3316
3317   arg1 = (Dali::Any *)jarg1;
3318   arg2 = (Dali::Any *)jarg2;
3319   if (!arg2) {
3320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3321     return 0;
3322   }
3323   {
3324     try {
3325       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (...) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3337       };
3338     }
3339   }
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_GetType(void * jarg1) {
3346   void * jresult ;
3347   Dali::Any *arg1 = (Dali::Any *) 0 ;
3348   std::type_info *result = 0 ;
3349
3350   arg1 = (Dali::Any *)jarg1;
3351   {
3352     try {
3353       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3354     } catch (std::out_of_range& e) {
3355       {
3356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3357       };
3358     } catch (std::exception& e) {
3359       {
3360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3361       };
3362     } catch (...) {
3363       {
3364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3365       };
3366     }
3367   }
3368   jresult = (void *)result;
3369   return jresult;
3370 }
3371
3372
3373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Any_Empty(void * jarg1) {
3374   unsigned int jresult ;
3375   Dali::Any *arg1 = (Dali::Any *) 0 ;
3376   bool result;
3377
3378   arg1 = (Dali::Any *)jarg1;
3379   {
3380     try {
3381       result = (bool)((Dali::Any const *)arg1)->Empty();
3382     } catch (std::out_of_range& e) {
3383       {
3384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3385       };
3386     } catch (std::exception& e) {
3387       {
3388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3389       };
3390     } catch (...) {
3391       {
3392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3393       };
3394     }
3395   }
3396   jresult = result;
3397   return jresult;
3398 }
3399
3400
3401 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3402   void * jresult ;
3403   std::type_info *arg1 = 0 ;
3404   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3405   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3406   Dali::Any::AnyContainerBase *result = 0 ;
3407
3408   arg1 = (std::type_info *)jarg1;
3409   if (!arg1) {
3410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3411     return 0;
3412   }
3413   arg2 = (Dali::Any::CloneFunc)jarg2;
3414   arg3 = (Dali::Any::DeleteFunc)jarg3;
3415   {
3416     try {
3417       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3418     } catch (std::out_of_range& e) {
3419       {
3420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3421       };
3422     } catch (std::exception& e) {
3423       {
3424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3425       };
3426     } catch (...) {
3427       {
3428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3429       };
3430     }
3431   }
3432   jresult = (void *)result;
3433   return jresult;
3434 }
3435
3436
3437 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_GetType(void * jarg1) {
3438   void * jresult ;
3439   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3440   std::type_info *result = 0 ;
3441
3442   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3443   {
3444     try {
3445       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3446     } catch (std::out_of_range& e) {
3447       {
3448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3449       };
3450     } catch (std::exception& e) {
3451       {
3452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (...) {
3455       {
3456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3457       };
3458     }
3459   }
3460   jresult = (void *)result;
3461   return jresult;
3462 }
3463
3464
3465 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mType_get(void * jarg1) {
3466   void * jresult ;
3467   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3468   ::std::type_info *result = 0 ;
3469
3470   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3471   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3472   jresult = (void *)result;
3473   return jresult;
3474 }
3475
3476
3477 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3478   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3479   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3480
3481   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3482   arg2 = (Dali::Any::CloneFunc)jarg2;
3483   if (arg1) (arg1)->mCloneFunc = arg2;
3484 }
3485
3486
3487 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3488   void * jresult ;
3489   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3490   Dali::Any::CloneFunc result;
3491
3492   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3493   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3494   jresult = (void *)result;
3495   return jresult;
3496 }
3497
3498
3499 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3500   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3501   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3502
3503   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3504   arg2 = (Dali::Any::DeleteFunc)jarg2;
3505   if (arg1) (arg1)->mDeleteFunc = arg2;
3506 }
3507
3508
3509 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3510   void * jresult ;
3511   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3512   Dali::Any::DeleteFunc result;
3513
3514   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3515   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3516   jresult = (void *)result;
3517   return jresult;
3518 }
3519
3520
3521 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Any_AnyContainerBase(void * jarg1) {
3522   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3523
3524   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3525   {
3526     try {
3527       delete arg1;
3528     } catch (std::out_of_range& e) {
3529       {
3530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3531       };
3532     } catch (std::exception& e) {
3533       {
3534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3535       };
3536     } catch (...) {
3537       {
3538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3539       };
3540     }
3541   }
3542 }
3543
3544
3545 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Any_mContainer_set(void * jarg1, void * jarg2) {
3546   Dali::Any *arg1 = (Dali::Any *) 0 ;
3547   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3548
3549   arg1 = (Dali::Any *)jarg1;
3550   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3551   if (arg1) (arg1)->mContainer = arg2;
3552 }
3553
3554
3555 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Any_mContainer_get(void * jarg1) {
3556   void * jresult ;
3557   Dali::Any *arg1 = (Dali::Any *) 0 ;
3558   Dali::Any::AnyContainerBase *result = 0 ;
3559
3560   arg1 = (Dali::Any *)jarg1;
3561   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3562   jresult = (void *)result;
3563   return jresult;
3564 }
3565
3566
3567 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliAssertMessage(char * jarg1, char * jarg2) {
3568   char *arg1 = (char *) 0 ;
3569   char *arg2 = (char *) 0 ;
3570
3571   arg1 = (char *)jarg1;
3572   arg2 = (char *)jarg2;
3573   {
3574     try {
3575       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3576     } catch (std::out_of_range& e) {
3577       {
3578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (std::exception& e) {
3581       {
3582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (...) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3587       };
3588     }
3589   }
3590 }
3591
3592
3593 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DaliException(char * jarg1, char * jarg2) {
3594   void * jresult ;
3595   char *arg1 = (char *) 0 ;
3596   char *arg2 = (char *) 0 ;
3597   Dali::DaliException *result = 0 ;
3598
3599   arg1 = (char *)jarg1;
3600   arg2 = (char *)jarg2;
3601   {
3602     try {
3603       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3604     } catch (std::out_of_range& e) {
3605       {
3606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3607       };
3608     } catch (std::exception& e) {
3609       {
3610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3611       };
3612     } catch (...) {
3613       {
3614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3615       };
3616     }
3617   }
3618   jresult = (void *)result;
3619   return jresult;
3620 }
3621
3622
3623 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliException_location_set(void * jarg1, char * jarg2) {
3624   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3625   char *arg2 = (char *) 0 ;
3626
3627   arg1 = (Dali::DaliException *)jarg1;
3628   arg2 = (char *)jarg2;
3629   {
3630     if (arg2) {
3631       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3632       strcpy((char *)arg1->location, (const char *)arg2);
3633     } else {
3634       arg1->location = 0;
3635     }
3636   }
3637 }
3638
3639
3640 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DaliException_location_get(void * jarg1) {
3641   char * jresult ;
3642   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3643   char *result = 0 ;
3644
3645   arg1 = (Dali::DaliException *)jarg1;
3646   result = (char *) ((arg1)->location);
3647   jresult = SWIG_csharp_string_callback((const char *)result);
3648   return jresult;
3649 }
3650
3651
3652 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_DaliException_condition_set(void * jarg1, char * jarg2) {
3653   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3654   char *arg2 = (char *) 0 ;
3655
3656   arg1 = (Dali::DaliException *)jarg1;
3657   arg2 = (char *)jarg2;
3658   {
3659     if (arg2) {
3660       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3661       strcpy((char *)arg1->condition, (const char *)arg2);
3662     } else {
3663       arg1->condition = 0;
3664     }
3665   }
3666 }
3667
3668
3669 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DaliException_condition_get(void * jarg1) {
3670   char * jresult ;
3671   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3672   char *result = 0 ;
3673
3674   arg1 = (Dali::DaliException *)jarg1;
3675   result = (char *) ((arg1)->condition);
3676   jresult = SWIG_csharp_string_callback((const char *)result);
3677   return jresult;
3678 }
3679
3680
3681 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DaliException(void * jarg1) {
3682   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3683
3684   arg1 = (Dali::DaliException *)jarg1;
3685   {
3686     try {
3687       delete arg1;
3688     } catch (std::out_of_range& e) {
3689       {
3690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3691       };
3692     } catch (std::exception& e) {
3693       {
3694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3695       };
3696     } catch (...) {
3697       {
3698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3699       };
3700     }
3701   }
3702 }
3703
3704
3705 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_0() {
3706   void * jresult ;
3707   Dali::Vector2 *result = 0 ;
3708
3709   {
3710     try {
3711       result = (Dali::Vector2 *)new Dali::Vector2();
3712     } catch (std::out_of_range& e) {
3713       {
3714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3715       };
3716     } catch (std::exception& e) {
3717       {
3718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3719       };
3720     } catch (...) {
3721       {
3722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3723       };
3724     }
3725   }
3726   jresult = (void *)result;
3727   return jresult;
3728 }
3729
3730
3731 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3732   void * jresult ;
3733   float arg1 ;
3734   float arg2 ;
3735   Dali::Vector2 *result = 0 ;
3736
3737   arg1 = (float)jarg1;
3738   arg2 = (float)jarg2;
3739   {
3740     try {
3741       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3742     } catch (std::out_of_range& e) {
3743       {
3744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3745       };
3746     } catch (std::exception& e) {
3747       {
3748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3749       };
3750     } catch (...) {
3751       {
3752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3753       };
3754     }
3755   }
3756   jresult = (void *)result;
3757   return jresult;
3758 }
3759
3760
3761 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_2(float* jarg1) {
3762   void * jresult ;
3763   float *arg1 = (float *) 0 ;
3764   Dali::Vector2 *result = 0 ;
3765
3766   arg1 = jarg1;
3767   {
3768     try {
3769       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3770     } catch (std::out_of_range& e) {
3771       {
3772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (std::exception& e) {
3775       {
3776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784   jresult = (void *)result;
3785
3786
3787   return jresult;
3788 }
3789
3790
3791 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_3(void * jarg1) {
3792   void * jresult ;
3793   Dali::Vector3 *arg1 = 0 ;
3794   Dali::Vector2 *result = 0 ;
3795
3796   arg1 = (Dali::Vector3 *)jarg1;
3797   if (!arg1) {
3798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3799     return 0;
3800   }
3801   {
3802     try {
3803       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3804     } catch (std::out_of_range& e) {
3805       {
3806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3807       };
3808     } catch (std::exception& e) {
3809       {
3810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3811       };
3812     } catch (...) {
3813       {
3814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3815       };
3816     }
3817   }
3818   jresult = (void *)result;
3819   return jresult;
3820 }
3821
3822
3823 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector2__SWIG_4(void * jarg1) {
3824   void * jresult ;
3825   Dali::Vector4 *arg1 = 0 ;
3826   Dali::Vector2 *result = 0 ;
3827
3828   arg1 = (Dali::Vector4 *)jarg1;
3829   if (!arg1) {
3830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3831     return 0;
3832   }
3833   {
3834     try {
3835       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3836     } catch (std::out_of_range& e) {
3837       {
3838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (std::exception& e) {
3841       {
3842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (...) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3847       };
3848     }
3849   }
3850   jresult = (void *)result;
3851   return jresult;
3852 }
3853
3854
3855 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_ONE_get() {
3856   void * jresult ;
3857   Dali::Vector2 *result = 0 ;
3858
3859   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3860   jresult = (void *)result;
3861   return jresult;
3862 }
3863
3864
3865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_XAXIS_get() {
3866   void * jresult ;
3867   Dali::Vector2 *result = 0 ;
3868
3869   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3870   jresult = (void *)result;
3871   return jresult;
3872 }
3873
3874
3875 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_YAXIS_get() {
3876   void * jresult ;
3877   Dali::Vector2 *result = 0 ;
3878
3879   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3880   jresult = (void *)result;
3881   return jresult;
3882 }
3883
3884
3885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_NEGATIVE_XAXIS_get() {
3886   void * jresult ;
3887   Dali::Vector2 *result = 0 ;
3888
3889   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3890   jresult = (void *)result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_NEGATIVE_YAXIS_get() {
3896   void * jresult ;
3897   Dali::Vector2 *result = 0 ;
3898
3899   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3900   jresult = (void *)result;
3901   return jresult;
3902 }
3903
3904
3905 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_ZERO_get() {
3906   void * jresult ;
3907   Dali::Vector2 *result = 0 ;
3908
3909   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3910   jresult = (void *)result;
3911   return jresult;
3912 }
3913
3914
3915 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3916   void * jresult ;
3917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3918   float *arg2 = (float *) 0 ;
3919   Dali::Vector2 *result = 0 ;
3920
3921   arg1 = (Dali::Vector2 *)jarg1;
3922   arg2 = jarg2;
3923   {
3924     try {
3925       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3926     } catch (std::out_of_range& e) {
3927       {
3928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3929       };
3930     } catch (std::exception& e) {
3931       {
3932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3933       };
3934     } catch (...) {
3935       {
3936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3937       };
3938     }
3939   }
3940   jresult = (void *)result;
3941
3942
3943   return jresult;
3944 }
3945
3946
3947 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3948   void * jresult ;
3949   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3950   Dali::Vector3 *arg2 = 0 ;
3951   Dali::Vector2 *result = 0 ;
3952
3953   arg1 = (Dali::Vector2 *)jarg1;
3954   arg2 = (Dali::Vector3 *)jarg2;
3955   if (!arg2) {
3956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3957     return 0;
3958   }
3959   {
3960     try {
3961       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3962     } catch (std::out_of_range& e) {
3963       {
3964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3965       };
3966     } catch (std::exception& e) {
3967       {
3968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3969       };
3970     } catch (...) {
3971       {
3972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3973       };
3974     }
3975   }
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3982   void * jresult ;
3983   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3984   Dali::Vector4 *arg2 = 0 ;
3985   Dali::Vector2 *result = 0 ;
3986
3987   arg1 = (Dali::Vector2 *)jarg1;
3988   arg2 = (Dali::Vector4 *)jarg2;
3989   if (!arg2) {
3990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3991     return 0;
3992   }
3993   {
3994     try {
3995       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3996     } catch (std::out_of_range& e) {
3997       {
3998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3999       };
4000     } catch (std::exception& e) {
4001       {
4002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4003       };
4004     } catch (...) {
4005       {
4006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4007       };
4008     }
4009   }
4010   jresult = (void *)result;
4011   return jresult;
4012 }
4013
4014
4015 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Add(void * jarg1, void * jarg2) {
4016   void * jresult ;
4017   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4018   Dali::Vector2 *arg2 = 0 ;
4019   Dali::Vector2 result;
4020
4021   arg1 = (Dali::Vector2 *)jarg1;
4022   arg2 = (Dali::Vector2 *)jarg2;
4023   if (!arg2) {
4024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4025     return 0;
4026   }
4027   {
4028     try {
4029       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4030     } catch (std::out_of_range& e) {
4031       {
4032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4033       };
4034     } catch (std::exception& e) {
4035       {
4036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4037       };
4038     } catch (...) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4041       };
4042     }
4043   }
4044   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4045   return jresult;
4046 }
4047
4048
4049 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_AddAssign(void * jarg1, void * jarg2) {
4050   void * jresult ;
4051   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4052   Dali::Vector2 *arg2 = 0 ;
4053   Dali::Vector2 *result = 0 ;
4054
4055   arg1 = (Dali::Vector2 *)jarg1;
4056   arg2 = (Dali::Vector2 *)jarg2;
4057   if (!arg2) {
4058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4059     return 0;
4060   }
4061   {
4062     try {
4063       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4064     } catch (std::out_of_range& e) {
4065       {
4066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4067       };
4068     } catch (std::exception& e) {
4069       {
4070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4071       };
4072     } catch (...) {
4073       {
4074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4075       };
4076     }
4077   }
4078   jresult = (void *)result;
4079   return jresult;
4080 }
4081
4082
4083 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4084   void * jresult ;
4085   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4086   Dali::Vector2 *arg2 = 0 ;
4087   Dali::Vector2 result;
4088
4089   arg1 = (Dali::Vector2 *)jarg1;
4090   arg2 = (Dali::Vector2 *)jarg2;
4091   if (!arg2) {
4092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4093     return 0;
4094   }
4095   {
4096     try {
4097       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4098     } catch (std::out_of_range& e) {
4099       {
4100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4101       };
4102     } catch (std::exception& e) {
4103       {
4104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4105       };
4106     } catch (...) {
4107       {
4108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4109       };
4110     }
4111   }
4112   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4113   return jresult;
4114 }
4115
4116
4117 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4118   void * jresult ;
4119   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4120   Dali::Vector2 *arg2 = 0 ;
4121   Dali::Vector2 *result = 0 ;
4122
4123   arg1 = (Dali::Vector2 *)jarg1;
4124   arg2 = (Dali::Vector2 *)jarg2;
4125   if (!arg2) {
4126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4127     return 0;
4128   }
4129   {
4130     try {
4131       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4132     } catch (std::out_of_range& e) {
4133       {
4134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4135       };
4136     } catch (std::exception& e) {
4137       {
4138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4139       };
4140     } catch (...) {
4141       {
4142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4143       };
4144     }
4145   }
4146   jresult = (void *)result;
4147   return jresult;
4148 }
4149
4150
4151 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4152   void * jresult ;
4153   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4154   Dali::Vector2 *arg2 = 0 ;
4155   Dali::Vector2 result;
4156
4157   arg1 = (Dali::Vector2 *)jarg1;
4158   arg2 = (Dali::Vector2 *)jarg2;
4159   if (!arg2) {
4160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4161     return 0;
4162   }
4163   {
4164     try {
4165       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4166     } catch (std::out_of_range& e) {
4167       {
4168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4169       };
4170     } catch (std::exception& e) {
4171       {
4172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4173       };
4174     } catch (...) {
4175       {
4176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4177       };
4178     }
4179   }
4180   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4181   return jresult;
4182 }
4183
4184
4185 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4186   void * jresult ;
4187   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4188   float arg2 ;
4189   Dali::Vector2 result;
4190
4191   arg1 = (Dali::Vector2 *)jarg1;
4192   arg2 = (float)jarg2;
4193   {
4194     try {
4195       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4196     } catch (std::out_of_range& e) {
4197       {
4198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4199       };
4200     } catch (std::exception& e) {
4201       {
4202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4203       };
4204     } catch (...) {
4205       {
4206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4207       };
4208     }
4209   }
4210   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4211   return jresult;
4212 }
4213
4214
4215 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4216   void * jresult ;
4217   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4218   Dali::Vector2 *arg2 = 0 ;
4219   Dali::Vector2 *result = 0 ;
4220
4221   arg1 = (Dali::Vector2 *)jarg1;
4222   arg2 = (Dali::Vector2 *)jarg2;
4223   if (!arg2) {
4224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4225     return 0;
4226   }
4227   {
4228     try {
4229       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4230     } catch (std::out_of_range& e) {
4231       {
4232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (std::exception& e) {
4235       {
4236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4237       };
4238     } catch (...) {
4239       {
4240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4241       };
4242     }
4243   }
4244   jresult = (void *)result;
4245   return jresult;
4246 }
4247
4248
4249 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4250   void * jresult ;
4251   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4252   float arg2 ;
4253   Dali::Vector2 *result = 0 ;
4254
4255   arg1 = (Dali::Vector2 *)jarg1;
4256   arg2 = (float)jarg2;
4257   {
4258     try {
4259       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4260     } catch (std::out_of_range& e) {
4261       {
4262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (std::exception& e) {
4265       {
4266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (...) {
4269       {
4270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4271       };
4272     }
4273   }
4274   jresult = (void *)result;
4275   return jresult;
4276 }
4277
4278
4279 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4280   void * jresult ;
4281   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4282   Dali::Vector2 *arg2 = 0 ;
4283   Dali::Vector2 result;
4284
4285   arg1 = (Dali::Vector2 *)jarg1;
4286   arg2 = (Dali::Vector2 *)jarg2;
4287   if (!arg2) {
4288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4289     return 0;
4290   }
4291   {
4292     try {
4293       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4294     } catch (std::out_of_range& e) {
4295       {
4296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (std::exception& e) {
4299       {
4300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (...) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4305       };
4306     }
4307   }
4308   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4314   void * jresult ;
4315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4316   float arg2 ;
4317   Dali::Vector2 result;
4318
4319   arg1 = (Dali::Vector2 *)jarg1;
4320   arg2 = (float)jarg2;
4321   {
4322     try {
4323       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4324     } catch (std::out_of_range& e) {
4325       {
4326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4327       };
4328     } catch (std::exception& e) {
4329       {
4330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (...) {
4333       {
4334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4335       };
4336     }
4337   }
4338   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4339   return jresult;
4340 }
4341
4342
4343 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4344   void * jresult ;
4345   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4346   Dali::Vector2 *arg2 = 0 ;
4347   Dali::Vector2 *result = 0 ;
4348
4349   arg1 = (Dali::Vector2 *)jarg1;
4350   arg2 = (Dali::Vector2 *)jarg2;
4351   if (!arg2) {
4352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4353     return 0;
4354   }
4355   {
4356     try {
4357       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4358     } catch (std::out_of_range& e) {
4359       {
4360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4361       };
4362     } catch (std::exception& e) {
4363       {
4364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4365       };
4366     } catch (...) {
4367       {
4368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4369       };
4370     }
4371   }
4372   jresult = (void *)result;
4373   return jresult;
4374 }
4375
4376
4377 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4378   void * jresult ;
4379   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4380   float arg2 ;
4381   Dali::Vector2 *result = 0 ;
4382
4383   arg1 = (Dali::Vector2 *)jarg1;
4384   arg2 = (float)jarg2;
4385   {
4386     try {
4387       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4388     } catch (std::out_of_range& e) {
4389       {
4390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4391       };
4392     } catch (std::exception& e) {
4393       {
4394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4395       };
4396     } catch (...) {
4397       {
4398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4399       };
4400     }
4401   }
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_Subtract__SWIG_1(void * jarg1) {
4408   void * jresult ;
4409   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4410   Dali::Vector2 result;
4411
4412   arg1 = (Dali::Vector2 *)jarg1;
4413   {
4414     try {
4415       result = ((Dali::Vector2 const *)arg1)->operator -();
4416     } catch (std::out_of_range& e) {
4417       {
4418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4419       };
4420     } catch (std::exception& e) {
4421       {
4422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4423       };
4424     } catch (...) {
4425       {
4426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4427       };
4428     }
4429   }
4430   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4431   return jresult;
4432 }
4433
4434
4435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector2_EqualTo(void * jarg1, void * jarg2) {
4436   unsigned int jresult ;
4437   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4438   Dali::Vector2 *arg2 = 0 ;
4439   bool result;
4440
4441   arg1 = (Dali::Vector2 *)jarg1;
4442   arg2 = (Dali::Vector2 *)jarg2;
4443   if (!arg2) {
4444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4445     return 0;
4446   }
4447   {
4448     try {
4449       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4450     } catch (std::out_of_range& e) {
4451       {
4452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4453       };
4454     } catch (std::exception& e) {
4455       {
4456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4457       };
4458     } catch (...) {
4459       {
4460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4461       };
4462     }
4463   }
4464   jresult = result;
4465   return jresult;
4466 }
4467
4468
4469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4470   unsigned int jresult ;
4471   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4472   Dali::Vector2 *arg2 = 0 ;
4473   bool result;
4474
4475   arg1 = (Dali::Vector2 *)jarg1;
4476   arg2 = (Dali::Vector2 *)jarg2;
4477   if (!arg2) {
4478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4479     return 0;
4480   }
4481   {
4482     try {
4483       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4484     } catch (std::out_of_range& e) {
4485       {
4486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4487       };
4488     } catch (std::exception& e) {
4489       {
4490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4491       };
4492     } catch (...) {
4493       {
4494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4495       };
4496     }
4497   }
4498   jresult = result;
4499   return jresult;
4500 }
4501
4502
4503 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4504   float jresult ;
4505   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4506   unsigned int arg2 ;
4507   float *result = 0 ;
4508
4509   arg1 = (Dali::Vector2 *)jarg1;
4510   arg2 = (unsigned int)jarg2;
4511   {
4512     try {
4513       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4514     } catch (std::out_of_range& e) {
4515       {
4516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4517       };
4518     } catch (std::exception& e) {
4519       {
4520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4521       };
4522     } catch (...) {
4523       {
4524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4525       };
4526     }
4527   }
4528   jresult = *result;
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Length(void * jarg1) {
4534   float jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   float result;
4537
4538   arg1 = (Dali::Vector2 *)jarg1;
4539   {
4540     try {
4541       result = (float)((Dali::Vector2 const *)arg1)->Length();
4542     } catch (std::out_of_range& e) {
4543       {
4544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (std::exception& e) {
4547       {
4548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (...) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4553       };
4554     }
4555   }
4556   jresult = result;
4557   return jresult;
4558 }
4559
4560
4561 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_LengthSquared(void * jarg1) {
4562   float jresult ;
4563   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4564   float result;
4565
4566   arg1 = (Dali::Vector2 *)jarg1;
4567   {
4568     try {
4569       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4570     } catch (std::out_of_range& e) {
4571       {
4572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (std::exception& e) {
4575       {
4576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4577       };
4578     } catch (...) {
4579       {
4580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4581       };
4582     }
4583   }
4584   jresult = result;
4585   return jresult;
4586 }
4587
4588
4589 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Normalize(void * jarg1) {
4590   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4591
4592   arg1 = (Dali::Vector2 *)jarg1;
4593   {
4594     try {
4595       (arg1)->Normalize();
4596     } catch (std::out_of_range& e) {
4597       {
4598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4599       };
4600     } catch (std::exception& e) {
4601       {
4602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4603       };
4604     } catch (...) {
4605       {
4606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4607       };
4608     }
4609   }
4610 }
4611
4612
4613 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4614   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4615   Dali::Vector2 *arg2 = 0 ;
4616   Dali::Vector2 *arg3 = 0 ;
4617
4618   arg1 = (Dali::Vector2 *)jarg1;
4619   arg2 = (Dali::Vector2 *)jarg2;
4620   if (!arg2) {
4621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4622     return ;
4623   }
4624   arg3 = (Dali::Vector2 *)jarg3;
4625   if (!arg3) {
4626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4627     return ;
4628   }
4629   {
4630     try {
4631       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4632     } catch (std::out_of_range& e) {
4633       {
4634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4635       };
4636     } catch (std::exception& e) {
4637       {
4638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4643       };
4644     }
4645   }
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector2_AsFloat__SWIG_0(void * jarg1) {
4650   void * jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   float *result = 0 ;
4653
4654   arg1 = (Dali::Vector2 *)jarg1;
4655   {
4656     try {
4657       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4658     } catch (std::out_of_range& e) {
4659       {
4660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4661       };
4662     } catch (std::exception& e) {
4663       {
4664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4665       };
4666     } catch (...) {
4667       {
4668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4669       };
4670     }
4671   }
4672   jresult = (void *)result;
4673   return jresult;
4674 }
4675
4676
4677 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_X_set(void * jarg1, float jarg2) {
4678   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4679   float arg2 ;
4680
4681   arg1 = (Dali::Vector2 *)jarg1;
4682   arg2 = (float)jarg2;
4683   if (arg1) (arg1)->x = arg2;
4684 }
4685
4686
4687 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_X_get(void * jarg1) {
4688   float jresult ;
4689   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4690   float result;
4691
4692   arg1 = (Dali::Vector2 *)jarg1;
4693   result = (float) ((arg1)->x);
4694   jresult = result;
4695   return jresult;
4696 }
4697
4698
4699 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Width_set(void * jarg1, float jarg2) {
4700   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4701   float arg2 ;
4702
4703   arg1 = (Dali::Vector2 *)jarg1;
4704   arg2 = (float)jarg2;
4705   if (arg1) (arg1)->width = arg2;
4706 }
4707
4708
4709 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Width_get(void * jarg1) {
4710   float jresult ;
4711   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4712   float result;
4713
4714   arg1 = (Dali::Vector2 *)jarg1;
4715   result = (float) ((arg1)->width);
4716   jresult = result;
4717   return jresult;
4718 }
4719
4720
4721 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Y_set(void * jarg1, float jarg2) {
4722   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4723   float arg2 ;
4724
4725   arg1 = (Dali::Vector2 *)jarg1;
4726   arg2 = (float)jarg2;
4727   if (arg1) (arg1)->y = arg2;
4728 }
4729
4730
4731 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Y_get(void * jarg1) {
4732   float jresult ;
4733   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4734   float result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   result = (float) ((arg1)->y);
4738   jresult = result;
4739   return jresult;
4740 }
4741
4742
4743 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector2_Height_set(void * jarg1, float jarg2) {
4744   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4745   float arg2 ;
4746
4747   arg1 = (Dali::Vector2 *)jarg1;
4748   arg2 = (float)jarg2;
4749   if (arg1) (arg1)->height = arg2;
4750 }
4751
4752
4753 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector2_Height_get(void * jarg1) {
4754   float jresult ;
4755   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4756   float result;
4757
4758   arg1 = (Dali::Vector2 *)jarg1;
4759   result = (float) ((arg1)->height);
4760   jresult = result;
4761   return jresult;
4762 }
4763
4764
4765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector2(void * jarg1) {
4766   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4767
4768   arg1 = (Dali::Vector2 *)jarg1;
4769   {
4770     try {
4771       delete arg1;
4772     } catch (std::out_of_range& e) {
4773       {
4774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4775       };
4776     } catch (std::exception& e) {
4777       {
4778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4779       };
4780     } catch (...) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4783       };
4784     }
4785   }
4786 }
4787
4788
4789 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_0(void * jarg1, void * jarg2) {
4790   void * jresult ;
4791   Dali::Vector2 *arg1 = 0 ;
4792   Dali::Vector2 *arg2 = 0 ;
4793   Dali::Vector2 result;
4794
4795   arg1 = (Dali::Vector2 *)jarg1;
4796   if (!arg1) {
4797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4798     return 0;
4799   }
4800   arg2 = (Dali::Vector2 *)jarg2;
4801   if (!arg2) {
4802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4803     return 0;
4804   }
4805   {
4806     try {
4807       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4808     } catch (std::out_of_range& e) {
4809       {
4810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4811       };
4812     } catch (std::exception& e) {
4813       {
4814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4815       };
4816     } catch (...) {
4817       {
4818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4819       };
4820     }
4821   }
4822   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4823   return jresult;
4824 }
4825
4826
4827 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_0(void * jarg1, void * jarg2) {
4828   void * jresult ;
4829   Dali::Vector2 *arg1 = 0 ;
4830   Dali::Vector2 *arg2 = 0 ;
4831   Dali::Vector2 result;
4832
4833   arg1 = (Dali::Vector2 *)jarg1;
4834   if (!arg1) {
4835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4836     return 0;
4837   }
4838   arg2 = (Dali::Vector2 *)jarg2;
4839   if (!arg2) {
4840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4841     return 0;
4842   }
4843   {
4844     try {
4845       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4846     } catch (std::out_of_range& e) {
4847       {
4848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (std::exception& e) {
4851       {
4852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (...) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4857       };
4858     }
4859   }
4860   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4861   return jresult;
4862 }
4863
4864
4865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4866   void * jresult ;
4867   Dali::Vector2 *arg1 = 0 ;
4868   float *arg2 = 0 ;
4869   float *arg3 = 0 ;
4870   float temp2 ;
4871   float temp3 ;
4872   Dali::Vector2 result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   if (!arg1) {
4876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4877     return 0;
4878   }
4879   temp2 = (float)jarg2;
4880   arg2 = &temp2;
4881   temp3 = (float)jarg3;
4882   arg3 = &temp3;
4883   {
4884     try {
4885       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4886     } catch (std::out_of_range& e) {
4887       {
4888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4889       };
4890     } catch (std::exception& e) {
4891       {
4892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (...) {
4895       {
4896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4897       };
4898     }
4899   }
4900   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_0() {
4906   void * jresult ;
4907   Dali::Vector3 *result = 0 ;
4908
4909   {
4910     try {
4911       result = (Dali::Vector3 *)new Dali::Vector3();
4912     } catch (std::out_of_range& e) {
4913       {
4914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4915       };
4916     } catch (std::exception& e) {
4917       {
4918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4919       };
4920     } catch (...) {
4921       {
4922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4923       };
4924     }
4925   }
4926   jresult = (void *)result;
4927   return jresult;
4928 }
4929
4930
4931 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4932   void * jresult ;
4933   float arg1 ;
4934   float arg2 ;
4935   float arg3 ;
4936   Dali::Vector3 *result = 0 ;
4937
4938   arg1 = (float)jarg1;
4939   arg2 = (float)jarg2;
4940   arg3 = (float)jarg3;
4941   {
4942     try {
4943       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4944     } catch (std::out_of_range& e) {
4945       {
4946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4947       };
4948     } catch (std::exception& e) {
4949       {
4950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4951       };
4952     } catch (...) {
4953       {
4954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4955       };
4956     }
4957   }
4958   jresult = (void *)result;
4959   return jresult;
4960 }
4961
4962
4963 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_2(float* jarg1) {
4964   void * jresult ;
4965   float *arg1 = (float *) 0 ;
4966   Dali::Vector3 *result = 0 ;
4967
4968   arg1 = jarg1;
4969   {
4970     try {
4971       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4972     } catch (std::out_of_range& e) {
4973       {
4974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4975       };
4976     } catch (std::exception& e) {
4977       {
4978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4979       };
4980     } catch (...) {
4981       {
4982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4983       };
4984     }
4985   }
4986   jresult = (void *)result;
4987
4988
4989   return jresult;
4990 }
4991
4992
4993 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_3(void * jarg1) {
4994   void * jresult ;
4995   Dali::Vector2 *arg1 = 0 ;
4996   Dali::Vector3 *result = 0 ;
4997
4998   arg1 = (Dali::Vector2 *)jarg1;
4999   if (!arg1) {
5000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5001     return 0;
5002   }
5003   {
5004     try {
5005       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5006     } catch (std::out_of_range& e) {
5007       {
5008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (std::exception& e) {
5011       {
5012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020   jresult = (void *)result;
5021   return jresult;
5022 }
5023
5024
5025 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector3__SWIG_4(void * jarg1) {
5026   void * jresult ;
5027   Dali::Vector4 *arg1 = 0 ;
5028   Dali::Vector3 *result = 0 ;
5029
5030   arg1 = (Dali::Vector4 *)jarg1;
5031   if (!arg1) {
5032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5033     return 0;
5034   }
5035   {
5036     try {
5037       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5038     } catch (std::out_of_range& e) {
5039       {
5040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5041       };
5042     } catch (std::exception& e) {
5043       {
5044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5045       };
5046     } catch (...) {
5047       {
5048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5049       };
5050     }
5051   }
5052   jresult = (void *)result;
5053   return jresult;
5054 }
5055
5056
5057 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ONE_get() {
5058   void * jresult ;
5059   Dali::Vector3 *result = 0 ;
5060
5061   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5062   jresult = (void *)result;
5063   return jresult;
5064 }
5065
5066
5067 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_XAXIS_get() {
5068   void * jresult ;
5069   Dali::Vector3 *result = 0 ;
5070
5071   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5072   jresult = (void *)result;
5073   return jresult;
5074 }
5075
5076
5077 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_YAXIS_get() {
5078   void * jresult ;
5079   Dali::Vector3 *result = 0 ;
5080
5081   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5082   jresult = (void *)result;
5083   return jresult;
5084 }
5085
5086
5087 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ZAXIS_get() {
5088   void * jresult ;
5089   Dali::Vector3 *result = 0 ;
5090
5091   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5092   jresult = (void *)result;
5093   return jresult;
5094 }
5095
5096
5097 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_XAXIS_get() {
5098   void * jresult ;
5099   Dali::Vector3 *result = 0 ;
5100
5101   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5102   jresult = (void *)result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_YAXIS_get() {
5108   void * jresult ;
5109   Dali::Vector3 *result = 0 ;
5110
5111   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5112   jresult = (void *)result;
5113   return jresult;
5114 }
5115
5116
5117 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_NEGATIVE_ZAXIS_get() {
5118   void * jresult ;
5119   Dali::Vector3 *result = 0 ;
5120
5121   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5122   jresult = (void *)result;
5123   return jresult;
5124 }
5125
5126
5127 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_ZERO_get() {
5128   void * jresult ;
5129   Dali::Vector3 *result = 0 ;
5130
5131   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5132   jresult = (void *)result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5138   void * jresult ;
5139   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5140   float *arg2 = (float *) 0 ;
5141   Dali::Vector3 *result = 0 ;
5142
5143   arg1 = (Dali::Vector3 *)jarg1;
5144   arg2 = jarg2;
5145   {
5146     try {
5147       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (...) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5159       };
5160     }
5161   }
5162   jresult = (void *)result;
5163
5164
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5170   void * jresult ;
5171   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5172   Dali::Vector2 *arg2 = 0 ;
5173   Dali::Vector3 *result = 0 ;
5174
5175   arg1 = (Dali::Vector3 *)jarg1;
5176   arg2 = (Dali::Vector2 *)jarg2;
5177   if (!arg2) {
5178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5179     return 0;
5180   }
5181   {
5182     try {
5183       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5184     } catch (std::out_of_range& e) {
5185       {
5186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5187       };
5188     } catch (std::exception& e) {
5189       {
5190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5191       };
5192     } catch (...) {
5193       {
5194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5195       };
5196     }
5197   }
5198   jresult = (void *)result;
5199   return jresult;
5200 }
5201
5202
5203 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5204   void * jresult ;
5205   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5206   Dali::Vector4 *arg2 = 0 ;
5207   Dali::Vector3 *result = 0 ;
5208
5209   arg1 = (Dali::Vector3 *)jarg1;
5210   arg2 = (Dali::Vector4 *)jarg2;
5211   if (!arg2) {
5212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5213     return 0;
5214   }
5215   {
5216     try {
5217       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5218     } catch (std::out_of_range& e) {
5219       {
5220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (std::exception& e) {
5223       {
5224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232   jresult = (void *)result;
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Add(void * jarg1, void * jarg2) {
5238   void * jresult ;
5239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5240   Dali::Vector3 *arg2 = 0 ;
5241   Dali::Vector3 result;
5242
5243   arg1 = (Dali::Vector3 *)jarg1;
5244   arg2 = (Dali::Vector3 *)jarg2;
5245   if (!arg2) {
5246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5247     return 0;
5248   }
5249   {
5250     try {
5251       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5252     } catch (std::out_of_range& e) {
5253       {
5254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5255       };
5256     } catch (std::exception& e) {
5257       {
5258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5259       };
5260     } catch (...) {
5261       {
5262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5263       };
5264     }
5265   }
5266   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5267   return jresult;
5268 }
5269
5270
5271 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_AddAssign(void * jarg1, void * jarg2) {
5272   void * jresult ;
5273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5274   Dali::Vector3 *arg2 = 0 ;
5275   Dali::Vector3 *result = 0 ;
5276
5277   arg1 = (Dali::Vector3 *)jarg1;
5278   arg2 = (Dali::Vector3 *)jarg2;
5279   if (!arg2) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5281     return 0;
5282   }
5283   {
5284     try {
5285       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5293       };
5294     } catch (...) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5297       };
5298     }
5299   }
5300   jresult = (void *)result;
5301   return jresult;
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5306   void * jresult ;
5307   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5308   Dali::Vector3 *arg2 = 0 ;
5309   Dali::Vector3 result;
5310
5311   arg1 = (Dali::Vector3 *)jarg1;
5312   arg2 = (Dali::Vector3 *)jarg2;
5313   if (!arg2) {
5314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5315     return 0;
5316   }
5317   {
5318     try {
5319       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5320     } catch (std::out_of_range& e) {
5321       {
5322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5323       };
5324     } catch (std::exception& e) {
5325       {
5326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5327       };
5328     } catch (...) {
5329       {
5330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5331       };
5332     }
5333   }
5334   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5340   void * jresult ;
5341   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5342   Dali::Vector3 *arg2 = 0 ;
5343   Dali::Vector3 *result = 0 ;
5344
5345   arg1 = (Dali::Vector3 *)jarg1;
5346   arg2 = (Dali::Vector3 *)jarg2;
5347   if (!arg2) {
5348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5349     return 0;
5350   }
5351   {
5352     try {
5353       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5354     } catch (std::out_of_range& e) {
5355       {
5356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5357       };
5358     } catch (std::exception& e) {
5359       {
5360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5361       };
5362     } catch (...) {
5363       {
5364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5365       };
5366     }
5367   }
5368   jresult = (void *)result;
5369   return jresult;
5370 }
5371
5372
5373 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5374   void * jresult ;
5375   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5376   Dali::Vector3 *arg2 = 0 ;
5377   Dali::Vector3 result;
5378
5379   arg1 = (Dali::Vector3 *)jarg1;
5380   arg2 = (Dali::Vector3 *)jarg2;
5381   if (!arg2) {
5382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5383     return 0;
5384   }
5385   {
5386     try {
5387       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5388     } catch (std::out_of_range& e) {
5389       {
5390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5391       };
5392     } catch (std::exception& e) {
5393       {
5394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5395       };
5396     } catch (...) {
5397       {
5398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5399       };
5400     }
5401   }
5402   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5408   void * jresult ;
5409   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5410   float arg2 ;
5411   Dali::Vector3 result;
5412
5413   arg1 = (Dali::Vector3 *)jarg1;
5414   arg2 = (float)jarg2;
5415   {
5416     try {
5417       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5418     } catch (std::out_of_range& e) {
5419       {
5420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5421       };
5422     } catch (std::exception& e) {
5423       {
5424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5425       };
5426     } catch (...) {
5427       {
5428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5429       };
5430     }
5431   }
5432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5433   return jresult;
5434 }
5435
5436
5437 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5438   void * jresult ;
5439   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5440   Dali::Vector3 *arg2 = 0 ;
5441   Dali::Vector3 *result = 0 ;
5442
5443   arg1 = (Dali::Vector3 *)jarg1;
5444   arg2 = (Dali::Vector3 *)jarg2;
5445   if (!arg2) {
5446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5447     return 0;
5448   }
5449   {
5450     try {
5451       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5452     } catch (std::out_of_range& e) {
5453       {
5454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5455       };
5456     } catch (std::exception& e) {
5457       {
5458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5459       };
5460     } catch (...) {
5461       {
5462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5463       };
5464     }
5465   }
5466   jresult = (void *)result;
5467   return jresult;
5468 }
5469
5470
5471 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5472   void * jresult ;
5473   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5474   float arg2 ;
5475   Dali::Vector3 *result = 0 ;
5476
5477   arg1 = (Dali::Vector3 *)jarg1;
5478   arg2 = (float)jarg2;
5479   {
5480     try {
5481       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5482     } catch (std::out_of_range& e) {
5483       {
5484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (std::exception& e) {
5487       {
5488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (...) {
5491       {
5492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5493       };
5494     }
5495   }
5496   jresult = (void *)result;
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5504   Dali::Quaternion *arg2 = 0 ;
5505   Dali::Vector3 *result = 0 ;
5506
5507   arg1 = (Dali::Vector3 *)jarg1;
5508   arg2 = (Dali::Quaternion *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (...) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5527       };
5528     }
5529   }
5530   jresult = (void *)result;
5531   return jresult;
5532 }
5533
5534
5535 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5536   void * jresult ;
5537   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5538   Dali::Vector3 *arg2 = 0 ;
5539   Dali::Vector3 result;
5540
5541   arg1 = (Dali::Vector3 *)jarg1;
5542   arg2 = (Dali::Vector3 *)jarg2;
5543   if (!arg2) {
5544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5545     return 0;
5546   }
5547   {
5548     try {
5549       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5550     } catch (std::out_of_range& e) {
5551       {
5552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5553       };
5554     } catch (std::exception& e) {
5555       {
5556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5557       };
5558     } catch (...) {
5559       {
5560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5561       };
5562     }
5563   }
5564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5570   void * jresult ;
5571   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5572   float arg2 ;
5573   Dali::Vector3 result;
5574
5575   arg1 = (Dali::Vector3 *)jarg1;
5576   arg2 = (float)jarg2;
5577   {
5578     try {
5579       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5580     } catch (std::out_of_range& e) {
5581       {
5582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (std::exception& e) {
5585       {
5586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (...) {
5589       {
5590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5591       };
5592     }
5593   }
5594   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5595   return jresult;
5596 }
5597
5598
5599 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5600   void * jresult ;
5601   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5602   Dali::Vector3 *arg2 = 0 ;
5603   Dali::Vector3 *result = 0 ;
5604
5605   arg1 = (Dali::Vector3 *)jarg1;
5606   arg2 = (Dali::Vector3 *)jarg2;
5607   if (!arg2) {
5608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5609     return 0;
5610   }
5611   {
5612     try {
5613       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5614     } catch (std::out_of_range& e) {
5615       {
5616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5617       };
5618     } catch (std::exception& e) {
5619       {
5620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5621       };
5622     } catch (...) {
5623       {
5624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5625       };
5626     }
5627   }
5628   jresult = (void *)result;
5629   return jresult;
5630 }
5631
5632
5633 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5634   void * jresult ;
5635   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5636   float arg2 ;
5637   Dali::Vector3 *result = 0 ;
5638
5639   arg1 = (Dali::Vector3 *)jarg1;
5640   arg2 = (float)jarg2;
5641   {
5642     try {
5643       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5644     } catch (std::out_of_range& e) {
5645       {
5646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5647       };
5648     } catch (std::exception& e) {
5649       {
5650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5651       };
5652     } catch (...) {
5653       {
5654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5655       };
5656     }
5657   }
5658   jresult = (void *)result;
5659   return jresult;
5660 }
5661
5662
5663 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Subtract__SWIG_1(void * jarg1) {
5664   void * jresult ;
5665   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5666   Dali::Vector3 result;
5667
5668   arg1 = (Dali::Vector3 *)jarg1;
5669   {
5670     try {
5671       result = ((Dali::Vector3 const *)arg1)->operator -();
5672     } catch (std::out_of_range& e) {
5673       {
5674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5675       };
5676     } catch (std::exception& e) {
5677       {
5678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5679       };
5680     } catch (...) {
5681       {
5682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5683       };
5684     }
5685   }
5686   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5687   return jresult;
5688 }
5689
5690
5691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector3_EqualTo(void * jarg1, void * jarg2) {
5692   unsigned int jresult ;
5693   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5694   Dali::Vector3 *arg2 = 0 ;
5695   bool result;
5696
5697   arg1 = (Dali::Vector3 *)jarg1;
5698   arg2 = (Dali::Vector3 *)jarg2;
5699   if (!arg2) {
5700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5701     return 0;
5702   }
5703   {
5704     try {
5705       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5706     } catch (std::out_of_range& e) {
5707       {
5708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5709       };
5710     } catch (std::exception& e) {
5711       {
5712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5713       };
5714     } catch (...) {
5715       {
5716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5717       };
5718     }
5719   }
5720   jresult = result;
5721   return jresult;
5722 }
5723
5724
5725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5726   unsigned int jresult ;
5727   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5728   Dali::Vector3 *arg2 = 0 ;
5729   bool result;
5730
5731   arg1 = (Dali::Vector3 *)jarg1;
5732   arg2 = (Dali::Vector3 *)jarg2;
5733   if (!arg2) {
5734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5735     return 0;
5736   }
5737   {
5738     try {
5739       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5740     } catch (std::out_of_range& e) {
5741       {
5742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (std::exception& e) {
5745       {
5746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (...) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5751       };
5752     }
5753   }
5754   jresult = result;
5755   return jresult;
5756 }
5757
5758
5759 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5760   float jresult ;
5761   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5762   unsigned int arg2 ;
5763   float *result = 0 ;
5764
5765   arg1 = (Dali::Vector3 *)jarg1;
5766   arg2 = (unsigned int)jarg2;
5767   {
5768     try {
5769       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5770     } catch (std::out_of_range& e) {
5771       {
5772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5773       };
5774     } catch (std::exception& e) {
5775       {
5776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5777       };
5778     } catch (...) {
5779       {
5780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5781       };
5782     }
5783   }
5784   jresult = *result;
5785   return jresult;
5786 }
5787
5788
5789 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Dot(void * jarg1, void * jarg2) {
5790   float jresult ;
5791   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5792   Dali::Vector3 *arg2 = 0 ;
5793   float result;
5794
5795   arg1 = (Dali::Vector3 *)jarg1;
5796   arg2 = (Dali::Vector3 *)jarg2;
5797   if (!arg2) {
5798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5799     return 0;
5800   }
5801   {
5802     try {
5803       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5804     } catch (std::out_of_range& e) {
5805       {
5806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5807       };
5808     } catch (std::exception& e) {
5809       {
5810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5811       };
5812     } catch (...) {
5813       {
5814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5815       };
5816     }
5817   }
5818   jresult = result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_Cross(void * jarg1, void * jarg2) {
5824   void * jresult ;
5825   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5826   Dali::Vector3 *arg2 = 0 ;
5827   Dali::Vector3 result;
5828
5829   arg1 = (Dali::Vector3 *)jarg1;
5830   arg2 = (Dali::Vector3 *)jarg2;
5831   if (!arg2) {
5832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5833     return 0;
5834   }
5835   {
5836     try {
5837       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5838     } catch (std::out_of_range& e) {
5839       {
5840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5841       };
5842     } catch (std::exception& e) {
5843       {
5844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5845       };
5846     } catch (...) {
5847       {
5848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5849       };
5850     }
5851   }
5852   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5853   return jresult;
5854 }
5855
5856
5857 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Length(void * jarg1) {
5858   float jresult ;
5859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5860   float result;
5861
5862   arg1 = (Dali::Vector3 *)jarg1;
5863   {
5864     try {
5865       result = (float)((Dali::Vector3 const *)arg1)->Length();
5866     } catch (std::out_of_range& e) {
5867       {
5868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5869       };
5870     } catch (std::exception& e) {
5871       {
5872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5873       };
5874     } catch (...) {
5875       {
5876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5877       };
5878     }
5879   }
5880   jresult = result;
5881   return jresult;
5882 }
5883
5884
5885 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_LengthSquared(void * jarg1) {
5886   float jresult ;
5887   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5888   float result;
5889
5890   arg1 = (Dali::Vector3 *)jarg1;
5891   {
5892     try {
5893       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5894     } catch (std::out_of_range& e) {
5895       {
5896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (std::exception& e) {
5899       {
5900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (...) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5905       };
5906     }
5907   }
5908   jresult = result;
5909   return jresult;
5910 }
5911
5912
5913 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Normalize(void * jarg1) {
5914   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5915
5916   arg1 = (Dali::Vector3 *)jarg1;
5917   {
5918     try {
5919       (arg1)->Normalize();
5920     } catch (std::out_of_range& e) {
5921       {
5922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5923       };
5924     } catch (std::exception& e) {
5925       {
5926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5927       };
5928     } catch (...) {
5929       {
5930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5931       };
5932     }
5933   }
5934 }
5935
5936
5937 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5939   Dali::Vector3 *arg2 = 0 ;
5940   Dali::Vector3 *arg3 = 0 ;
5941
5942   arg1 = (Dali::Vector3 *)jarg1;
5943   arg2 = (Dali::Vector3 *)jarg2;
5944   if (!arg2) {
5945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5946     return ;
5947   }
5948   arg3 = (Dali::Vector3 *)jarg3;
5949   if (!arg3) {
5950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5951     return ;
5952   }
5953   {
5954     try {
5955       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
5956     } catch (std::out_of_range& e) {
5957       {
5958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5959       };
5960     } catch (std::exception& e) {
5961       {
5962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5963       };
5964     } catch (...) {
5965       {
5966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5967       };
5968     }
5969   }
5970 }
5971
5972
5973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_AsFloat__SWIG_0(void * jarg1) {
5974   void * jresult ;
5975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5976   float *result = 0 ;
5977
5978   arg1 = (Dali::Vector3 *)jarg1;
5979   {
5980     try {
5981       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
5982     } catch (std::out_of_range& e) {
5983       {
5984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5985       };
5986     } catch (std::exception& e) {
5987       {
5988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (...) {
5991       {
5992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5993       };
5994     }
5995   }
5996   jresult = (void *)result;
5997   return jresult;
5998 }
5999
6000
6001 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6002   void * jresult ;
6003   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6004   Dali::Vector2 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   {
6008     try {
6009       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6010     } catch (std::out_of_range& e) {
6011       {
6012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (std::exception& e) {
6015       {
6016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (...) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6021       };
6022     }
6023   }
6024   jresult = (void *)result;
6025   return jresult;
6026 }
6027
6028
6029 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6030   void * jresult ;
6031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6032   Dali::Vector2 *result = 0 ;
6033
6034   arg1 = (Dali::Vector3 *)jarg1;
6035   {
6036     try {
6037       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6045       };
6046     } catch (...) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6049       };
6050     }
6051   }
6052   jresult = (void *)result;
6053   return jresult;
6054 }
6055
6056
6057 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_X_set(void * jarg1, float jarg2) {
6058   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6059   float arg2 ;
6060
6061   arg1 = (Dali::Vector3 *)jarg1;
6062   arg2 = (float)jarg2;
6063   if (arg1) (arg1)->x = arg2;
6064 }
6065
6066
6067 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_X_get(void * jarg1) {
6068   float jresult ;
6069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6070   float result;
6071
6072   arg1 = (Dali::Vector3 *)jarg1;
6073   result = (float) ((arg1)->x);
6074   jresult = result;
6075   return jresult;
6076 }
6077
6078
6079 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Width_set(void * jarg1, float jarg2) {
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   float arg2 ;
6082
6083   arg1 = (Dali::Vector3 *)jarg1;
6084   arg2 = (float)jarg2;
6085   if (arg1) (arg1)->width = arg2;
6086 }
6087
6088
6089 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Width_get(void * jarg1) {
6090   float jresult ;
6091   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6092   float result;
6093
6094   arg1 = (Dali::Vector3 *)jarg1;
6095   result = (float) ((arg1)->width);
6096   jresult = result;
6097   return jresult;
6098 }
6099
6100
6101 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_r_set(void * jarg1, float jarg2) {
6102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6103   float arg2 ;
6104
6105   arg1 = (Dali::Vector3 *)jarg1;
6106   arg2 = (float)jarg2;
6107   if (arg1) (arg1)->r = arg2;
6108 }
6109
6110
6111 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_r_get(void * jarg1) {
6112   float jresult ;
6113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6114   float result;
6115
6116   arg1 = (Dali::Vector3 *)jarg1;
6117   result = (float) ((arg1)->r);
6118   jresult = result;
6119   return jresult;
6120 }
6121
6122
6123 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Y_set(void * jarg1, float jarg2) {
6124   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6125   float arg2 ;
6126
6127   arg1 = (Dali::Vector3 *)jarg1;
6128   arg2 = (float)jarg2;
6129   if (arg1) (arg1)->y = arg2;
6130 }
6131
6132
6133 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Y_get(void * jarg1) {
6134   float jresult ;
6135   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6136   float result;
6137
6138   arg1 = (Dali::Vector3 *)jarg1;
6139   result = (float) ((arg1)->y);
6140   jresult = result;
6141   return jresult;
6142 }
6143
6144
6145 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Height_set(void * jarg1, float jarg2) {
6146   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6147   float arg2 ;
6148
6149   arg1 = (Dali::Vector3 *)jarg1;
6150   arg2 = (float)jarg2;
6151   if (arg1) (arg1)->height = arg2;
6152 }
6153
6154
6155 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Height_get(void * jarg1) {
6156   float jresult ;
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float result;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   result = (float) ((arg1)->height);
6162   jresult = result;
6163   return jresult;
6164 }
6165
6166
6167 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_g_set(void * jarg1, float jarg2) {
6168   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6169   float arg2 ;
6170
6171   arg1 = (Dali::Vector3 *)jarg1;
6172   arg2 = (float)jarg2;
6173   if (arg1) (arg1)->g = arg2;
6174 }
6175
6176
6177 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_g_get(void * jarg1) {
6178   float jresult ;
6179   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6180   float result;
6181
6182   arg1 = (Dali::Vector3 *)jarg1;
6183   result = (float) ((arg1)->g);
6184   jresult = result;
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Z_set(void * jarg1, float jarg2) {
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   float arg2 ;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   arg2 = (float)jarg2;
6195   if (arg1) (arg1)->z = arg2;
6196 }
6197
6198
6199 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Z_get(void * jarg1) {
6200   float jresult ;
6201   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6202   float result;
6203
6204   arg1 = (Dali::Vector3 *)jarg1;
6205   result = (float) ((arg1)->z);
6206   jresult = result;
6207   return jresult;
6208 }
6209
6210
6211 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_Depth_set(void * jarg1, float jarg2) {
6212   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6213   float arg2 ;
6214
6215   arg1 = (Dali::Vector3 *)jarg1;
6216   arg2 = (float)jarg2;
6217   if (arg1) (arg1)->depth = arg2;
6218 }
6219
6220
6221 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_Depth_get(void * jarg1) {
6222   float jresult ;
6223   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6224   float result;
6225
6226   arg1 = (Dali::Vector3 *)jarg1;
6227   result = (float) ((arg1)->depth);
6228   jresult = result;
6229   return jresult;
6230 }
6231
6232
6233 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector3_b_set(void * jarg1, float jarg2) {
6234   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6235   float arg2 ;
6236
6237   arg1 = (Dali::Vector3 *)jarg1;
6238   arg2 = (float)jarg2;
6239   if (arg1) (arg1)->b = arg2;
6240 }
6241
6242
6243 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector3_b_get(void * jarg1) {
6244   float jresult ;
6245   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6246   float result;
6247
6248   arg1 = (Dali::Vector3 *)jarg1;
6249   result = (float) ((arg1)->b);
6250   jresult = result;
6251   return jresult;
6252 }
6253
6254
6255 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector3(void * jarg1) {
6256   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6257
6258   arg1 = (Dali::Vector3 *)jarg1;
6259   {
6260     try {
6261       delete arg1;
6262     } catch (std::out_of_range& e) {
6263       {
6264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6265       };
6266     } catch (std::exception& e) {
6267       {
6268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6269       };
6270     } catch (...) {
6271       {
6272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6273       };
6274     }
6275   }
6276 }
6277
6278
6279 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_1(void * jarg1, void * jarg2) {
6280   void * jresult ;
6281   Dali::Vector3 *arg1 = 0 ;
6282   Dali::Vector3 *arg2 = 0 ;
6283   Dali::Vector3 result;
6284
6285   arg1 = (Dali::Vector3 *)jarg1;
6286   if (!arg1) {
6287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6288     return 0;
6289   }
6290   arg2 = (Dali::Vector3 *)jarg2;
6291   if (!arg2) {
6292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6293     return 0;
6294   }
6295   {
6296     try {
6297       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6298     } catch (std::out_of_range& e) {
6299       {
6300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6301       };
6302     } catch (std::exception& e) {
6303       {
6304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6305       };
6306     } catch (...) {
6307       {
6308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6309       };
6310     }
6311   }
6312   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6313   return jresult;
6314 }
6315
6316
6317 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_1(void * jarg1, void * jarg2) {
6318   void * jresult ;
6319   Dali::Vector3 *arg1 = 0 ;
6320   Dali::Vector3 *arg2 = 0 ;
6321   Dali::Vector3 result;
6322
6323   arg1 = (Dali::Vector3 *)jarg1;
6324   if (!arg1) {
6325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6326     return 0;
6327   }
6328   arg2 = (Dali::Vector3 *)jarg2;
6329   if (!arg2) {
6330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6331     return 0;
6332   }
6333   {
6334     try {
6335       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6336     } catch (std::out_of_range& e) {
6337       {
6338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6339       };
6340     } catch (std::exception& e) {
6341       {
6342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6343       };
6344     } catch (...) {
6345       {
6346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6347       };
6348     }
6349   }
6350   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6351   return jresult;
6352 }
6353
6354
6355 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6356   void * jresult ;
6357   Dali::Vector3 *arg1 = 0 ;
6358   float *arg2 = 0 ;
6359   float *arg3 = 0 ;
6360   float temp2 ;
6361   float temp3 ;
6362   Dali::Vector3 result;
6363
6364   arg1 = (Dali::Vector3 *)jarg1;
6365   if (!arg1) {
6366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6367     return 0;
6368   }
6369   temp2 = (float)jarg2;
6370   arg2 = &temp2;
6371   temp3 = (float)jarg3;
6372   arg3 = &temp3;
6373   {
6374     try {
6375       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6376     } catch (std::out_of_range& e) {
6377       {
6378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6379       };
6380     } catch (std::exception& e) {
6381       {
6382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (...) {
6385       {
6386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6387       };
6388     }
6389   }
6390   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6391   return jresult;
6392 }
6393
6394
6395 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_0() {
6396   void * jresult ;
6397   Dali::Vector4 *result = 0 ;
6398
6399   {
6400     try {
6401       result = (Dali::Vector4 *)new Dali::Vector4();
6402     } catch (std::out_of_range& e) {
6403       {
6404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6405       };
6406     } catch (std::exception& e) {
6407       {
6408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6409       };
6410     } catch (...) {
6411       {
6412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6413       };
6414     }
6415   }
6416   jresult = (void *)result;
6417   return jresult;
6418 }
6419
6420
6421 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6422   void * jresult ;
6423   float arg1 ;
6424   float arg2 ;
6425   float arg3 ;
6426   float arg4 ;
6427   Dali::Vector4 *result = 0 ;
6428
6429   arg1 = (float)jarg1;
6430   arg2 = (float)jarg2;
6431   arg3 = (float)jarg3;
6432   arg4 = (float)jarg4;
6433   {
6434     try {
6435       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6436     } catch (std::out_of_range& e) {
6437       {
6438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6439       };
6440     } catch (std::exception& e) {
6441       {
6442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6443       };
6444     } catch (...) {
6445       {
6446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6447       };
6448     }
6449   }
6450   jresult = (void *)result;
6451   return jresult;
6452 }
6453
6454
6455 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_2(float* jarg1) {
6456   void * jresult ;
6457   float *arg1 = (float *) 0 ;
6458   Dali::Vector4 *result = 0 ;
6459
6460   arg1 = jarg1;
6461   {
6462     try {
6463       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6464     } catch (std::out_of_range& e) {
6465       {
6466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (std::exception& e) {
6469       {
6470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6471       };
6472     } catch (...) {
6473       {
6474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6475       };
6476     }
6477   }
6478   jresult = (void *)result;
6479
6480
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_3(void * jarg1) {
6486   void * jresult ;
6487   Dali::Vector2 *arg1 = 0 ;
6488   Dali::Vector4 *result = 0 ;
6489
6490   arg1 = (Dali::Vector2 *)jarg1;
6491   if (!arg1) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (...) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6509       };
6510     }
6511   }
6512   jresult = (void *)result;
6513   return jresult;
6514 }
6515
6516
6517 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Vector4__SWIG_4(void * jarg1) {
6518   void * jresult ;
6519   Dali::Vector3 *arg1 = 0 ;
6520   Dali::Vector4 *result = 0 ;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   if (!arg1) {
6524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6525     return 0;
6526   }
6527   {
6528     try {
6529       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6530     } catch (std::out_of_range& e) {
6531       {
6532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6533       };
6534     } catch (std::exception& e) {
6535       {
6536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6537       };
6538     } catch (...) {
6539       {
6540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6541       };
6542     }
6543   }
6544   jresult = (void *)result;
6545   return jresult;
6546 }
6547
6548
6549 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ONE_get() {
6550   void * jresult ;
6551   Dali::Vector4 *result = 0 ;
6552
6553   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6554   jresult = (void *)result;
6555   return jresult;
6556 }
6557
6558
6559 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_XAXIS_get() {
6560   void * jresult ;
6561   Dali::Vector4 *result = 0 ;
6562
6563   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6564   jresult = (void *)result;
6565   return jresult;
6566 }
6567
6568
6569 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_YAXIS_get() {
6570   void * jresult ;
6571   Dali::Vector4 *result = 0 ;
6572
6573   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6574   jresult = (void *)result;
6575   return jresult;
6576 }
6577
6578
6579 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ZAXIS_get() {
6580   void * jresult ;
6581   Dali::Vector4 *result = 0 ;
6582
6583   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6584   jresult = (void *)result;
6585   return jresult;
6586 }
6587
6588
6589 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_ZERO_get() {
6590   void * jresult ;
6591   Dali::Vector4 *result = 0 ;
6592
6593   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6594   jresult = (void *)result;
6595   return jresult;
6596 }
6597
6598
6599 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6600   void * jresult ;
6601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6602   float *arg2 = (float *) 0 ;
6603   Dali::Vector4 *result = 0 ;
6604
6605   arg1 = (Dali::Vector4 *)jarg1;
6606   arg2 = jarg2;
6607   {
6608     try {
6609       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (...) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6621       };
6622     }
6623   }
6624   jresult = (void *)result;
6625
6626
6627   return jresult;
6628 }
6629
6630
6631 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6632   void * jresult ;
6633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6634   Dali::Vector2 *arg2 = 0 ;
6635   Dali::Vector4 *result = 0 ;
6636
6637   arg1 = (Dali::Vector4 *)jarg1;
6638   arg2 = (Dali::Vector2 *)jarg2;
6639   if (!arg2) {
6640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6641     return 0;
6642   }
6643   {
6644     try {
6645       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (...) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6657       };
6658     }
6659   }
6660   jresult = (void *)result;
6661   return jresult;
6662 }
6663
6664
6665 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6666   void * jresult ;
6667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6668   Dali::Vector3 *arg2 = 0 ;
6669   Dali::Vector4 *result = 0 ;
6670
6671   arg1 = (Dali::Vector4 *)jarg1;
6672   arg2 = (Dali::Vector3 *)jarg2;
6673   if (!arg2) {
6674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6675     return 0;
6676   }
6677   {
6678     try {
6679       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (...) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6691       };
6692     }
6693   }
6694   jresult = (void *)result;
6695   return jresult;
6696 }
6697
6698
6699 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Add(void * jarg1, void * jarg2) {
6700   void * jresult ;
6701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6702   Dali::Vector4 *arg2 = 0 ;
6703   Dali::Vector4 result;
6704
6705   arg1 = (Dali::Vector4 *)jarg1;
6706   arg2 = (Dali::Vector4 *)jarg2;
6707   if (!arg2) {
6708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6709     return 0;
6710   }
6711   {
6712     try {
6713       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6714     } catch (std::out_of_range& e) {
6715       {
6716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (std::exception& e) {
6719       {
6720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (...) {
6723       {
6724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6725       };
6726     }
6727   }
6728   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6729   return jresult;
6730 }
6731
6732
6733 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_AddAssign(void * jarg1, void * jarg2) {
6734   void * jresult ;
6735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6736   Dali::Vector4 *arg2 = 0 ;
6737   Dali::Vector4 *result = 0 ;
6738
6739   arg1 = (Dali::Vector4 *)jarg1;
6740   arg2 = (Dali::Vector4 *)jarg2;
6741   if (!arg2) {
6742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6743     return 0;
6744   }
6745   {
6746     try {
6747       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6748     } catch (std::out_of_range& e) {
6749       {
6750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6751       };
6752     } catch (std::exception& e) {
6753       {
6754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6755       };
6756     } catch (...) {
6757       {
6758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6759       };
6760     }
6761   }
6762   jresult = (void *)result;
6763   return jresult;
6764 }
6765
6766
6767 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6768   void * jresult ;
6769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6770   Dali::Vector4 *arg2 = 0 ;
6771   Dali::Vector4 result;
6772
6773   arg1 = (Dali::Vector4 *)jarg1;
6774   arg2 = (Dali::Vector4 *)jarg2;
6775   if (!arg2) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6777     return 0;
6778   }
6779   {
6780     try {
6781       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6782     } catch (std::out_of_range& e) {
6783       {
6784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6785       };
6786     } catch (std::exception& e) {
6787       {
6788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6789       };
6790     } catch (...) {
6791       {
6792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6793       };
6794     }
6795   }
6796   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6797   return jresult;
6798 }
6799
6800
6801 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6802   void * jresult ;
6803   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6804   Dali::Vector4 *arg2 = 0 ;
6805   Dali::Vector4 *result = 0 ;
6806
6807   arg1 = (Dali::Vector4 *)jarg1;
6808   arg2 = (Dali::Vector4 *)jarg2;
6809   if (!arg2) {
6810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6811     return 0;
6812   }
6813   {
6814     try {
6815       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6816     } catch (std::out_of_range& e) {
6817       {
6818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6819       };
6820     } catch (std::exception& e) {
6821       {
6822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6823       };
6824     } catch (...) {
6825       {
6826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6827       };
6828     }
6829   }
6830   jresult = (void *)result;
6831   return jresult;
6832 }
6833
6834
6835 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6836   void * jresult ;
6837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6838   Dali::Vector4 *arg2 = 0 ;
6839   Dali::Vector4 result;
6840
6841   arg1 = (Dali::Vector4 *)jarg1;
6842   arg2 = (Dali::Vector4 *)jarg2;
6843   if (!arg2) {
6844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6845     return 0;
6846   }
6847   {
6848     try {
6849       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6850     } catch (std::out_of_range& e) {
6851       {
6852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6853       };
6854     } catch (std::exception& e) {
6855       {
6856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (...) {
6859       {
6860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6861       };
6862     }
6863   }
6864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6865   return jresult;
6866 }
6867
6868
6869 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6870   void * jresult ;
6871   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6872   float arg2 ;
6873   Dali::Vector4 result;
6874
6875   arg1 = (Dali::Vector4 *)jarg1;
6876   arg2 = (float)jarg2;
6877   {
6878     try {
6879       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6880     } catch (std::out_of_range& e) {
6881       {
6882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6883       };
6884     } catch (std::exception& e) {
6885       {
6886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (...) {
6889       {
6890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6891       };
6892     }
6893   }
6894   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6895   return jresult;
6896 }
6897
6898
6899 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6900   void * jresult ;
6901   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6902   Dali::Vector4 *arg2 = 0 ;
6903   Dali::Vector4 *result = 0 ;
6904
6905   arg1 = (Dali::Vector4 *)jarg1;
6906   arg2 = (Dali::Vector4 *)jarg2;
6907   if (!arg2) {
6908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6909     return 0;
6910   }
6911   {
6912     try {
6913       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6914     } catch (std::out_of_range& e) {
6915       {
6916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6917       };
6918     } catch (std::exception& e) {
6919       {
6920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6921       };
6922     } catch (...) {
6923       {
6924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6925       };
6926     }
6927   }
6928   jresult = (void *)result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6934   void * jresult ;
6935   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6936   float arg2 ;
6937   Dali::Vector4 *result = 0 ;
6938
6939   arg1 = (Dali::Vector4 *)jarg1;
6940   arg2 = (float)jarg2;
6941   {
6942     try {
6943       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
6944     } catch (std::out_of_range& e) {
6945       {
6946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6947       };
6948     } catch (std::exception& e) {
6949       {
6950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6951       };
6952     } catch (...) {
6953       {
6954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6955       };
6956     }
6957   }
6958   jresult = (void *)result;
6959   return jresult;
6960 }
6961
6962
6963 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
6964   void * jresult ;
6965   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6966   Dali::Vector4 *arg2 = 0 ;
6967   Dali::Vector4 result;
6968
6969   arg1 = (Dali::Vector4 *)jarg1;
6970   arg2 = (Dali::Vector4 *)jarg2;
6971   if (!arg2) {
6972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6973     return 0;
6974   }
6975   {
6976     try {
6977       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
6978     } catch (std::out_of_range& e) {
6979       {
6980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6981       };
6982     } catch (std::exception& e) {
6983       {
6984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6985       };
6986     } catch (...) {
6987       {
6988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6989       };
6990     }
6991   }
6992   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
6998   void * jresult ;
6999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7000   float arg2 ;
7001   Dali::Vector4 result;
7002
7003   arg1 = (Dali::Vector4 *)jarg1;
7004   arg2 = (float)jarg2;
7005   {
7006     try {
7007       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7008     } catch (std::out_of_range& e) {
7009       {
7010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7011       };
7012     } catch (std::exception& e) {
7013       {
7014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7015       };
7016     } catch (...) {
7017       {
7018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7019       };
7020     }
7021   }
7022   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7023   return jresult;
7024 }
7025
7026
7027 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7028   void * jresult ;
7029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7030   Dali::Vector4 *arg2 = 0 ;
7031   Dali::Vector4 *result = 0 ;
7032
7033   arg1 = (Dali::Vector4 *)jarg1;
7034   arg2 = (Dali::Vector4 *)jarg2;
7035   if (!arg2) {
7036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7037     return 0;
7038   }
7039   {
7040     try {
7041       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7042     } catch (std::out_of_range& e) {
7043       {
7044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7045       };
7046     } catch (std::exception& e) {
7047       {
7048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7049       };
7050     } catch (...) {
7051       {
7052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7053       };
7054     }
7055   }
7056   jresult = (void *)result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7062   void * jresult ;
7063   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7064   float arg2 ;
7065   Dali::Vector4 *result = 0 ;
7066
7067   arg1 = (Dali::Vector4 *)jarg1;
7068   arg2 = (float)jarg2;
7069   {
7070     try {
7071       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7072     } catch (std::out_of_range& e) {
7073       {
7074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7075       };
7076     } catch (std::exception& e) {
7077       {
7078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7079       };
7080     } catch (...) {
7081       {
7082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7083       };
7084     }
7085   }
7086   jresult = (void *)result;
7087   return jresult;
7088 }
7089
7090
7091 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Subtract__SWIG_1(void * jarg1) {
7092   void * jresult ;
7093   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7094   Dali::Vector4 result;
7095
7096   arg1 = (Dali::Vector4 *)jarg1;
7097   {
7098     try {
7099       result = ((Dali::Vector4 const *)arg1)->operator -();
7100     } catch (std::out_of_range& e) {
7101       {
7102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7103       };
7104     } catch (std::exception& e) {
7105       {
7106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7107       };
7108     } catch (...) {
7109       {
7110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7111       };
7112     }
7113   }
7114   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7115   return jresult;
7116 }
7117
7118
7119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector4_EqualTo(void * jarg1, void * jarg2) {
7120   unsigned int jresult ;
7121   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7122   Dali::Vector4 *arg2 = 0 ;
7123   bool result;
7124
7125   arg1 = (Dali::Vector4 *)jarg1;
7126   arg2 = (Dali::Vector4 *)jarg2;
7127   if (!arg2) {
7128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7129     return 0;
7130   }
7131   {
7132     try {
7133       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7134     } catch (std::out_of_range& e) {
7135       {
7136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7137       };
7138     } catch (std::exception& e) {
7139       {
7140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7141       };
7142     } catch (...) {
7143       {
7144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7145       };
7146     }
7147   }
7148   jresult = result;
7149   return jresult;
7150 }
7151
7152
7153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7154   unsigned int jresult ;
7155   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7156   Dali::Vector4 *arg2 = 0 ;
7157   bool result;
7158
7159   arg1 = (Dali::Vector4 *)jarg1;
7160   arg2 = (Dali::Vector4 *)jarg2;
7161   if (!arg2) {
7162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7163     return 0;
7164   }
7165   {
7166     try {
7167       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7168     } catch (std::out_of_range& e) {
7169       {
7170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7171       };
7172     } catch (std::exception& e) {
7173       {
7174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7175       };
7176     } catch (...) {
7177       {
7178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7179       };
7180     }
7181   }
7182   jresult = result;
7183   return jresult;
7184 }
7185
7186
7187 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7188   float jresult ;
7189   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7190   unsigned int arg2 ;
7191   float *result = 0 ;
7192
7193   arg1 = (Dali::Vector4 *)jarg1;
7194   arg2 = (unsigned int)jarg2;
7195   {
7196     try {
7197       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (...) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7209       };
7210     }
7211   }
7212   jresult = *result;
7213   return jresult;
7214 }
7215
7216
7217 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7218   float jresult ;
7219   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7220   Dali::Vector3 *arg2 = 0 ;
7221   float result;
7222
7223   arg1 = (Dali::Vector4 *)jarg1;
7224   arg2 = (Dali::Vector3 *)jarg2;
7225   if (!arg2) {
7226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7227     return 0;
7228   }
7229   {
7230     try {
7231       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7232     } catch (std::out_of_range& e) {
7233       {
7234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7235       };
7236     } catch (std::exception& e) {
7237       {
7238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7239       };
7240     } catch (...) {
7241       {
7242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7243       };
7244     }
7245   }
7246   jresult = result;
7247   return jresult;
7248 }
7249
7250
7251 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7252   float jresult ;
7253   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7254   Dali::Vector4 *arg2 = 0 ;
7255   float result;
7256
7257   arg1 = (Dali::Vector4 *)jarg1;
7258   arg2 = (Dali::Vector4 *)jarg2;
7259   if (!arg2) {
7260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7261     return 0;
7262   }
7263   {
7264     try {
7265       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7266     } catch (std::out_of_range& e) {
7267       {
7268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (std::exception& e) {
7271       {
7272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (...) {
7275       {
7276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7277       };
7278     }
7279   }
7280   jresult = result;
7281   return jresult;
7282 }
7283
7284
7285 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Dot4(void * jarg1, void * jarg2) {
7286   float jresult ;
7287   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7288   Dali::Vector4 *arg2 = 0 ;
7289   float result;
7290
7291   arg1 = (Dali::Vector4 *)jarg1;
7292   arg2 = (Dali::Vector4 *)jarg2;
7293   if (!arg2) {
7294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7295     return 0;
7296   }
7297   {
7298     try {
7299       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7300     } catch (std::out_of_range& e) {
7301       {
7302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7303       };
7304     } catch (std::exception& e) {
7305       {
7306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7307       };
7308     } catch (...) {
7309       {
7310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7311       };
7312     }
7313   }
7314   jresult = result;
7315   return jresult;
7316 }
7317
7318
7319 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_Cross(void * jarg1, void * jarg2) {
7320   void * jresult ;
7321   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7322   Dali::Vector4 *arg2 = 0 ;
7323   Dali::Vector4 result;
7324
7325   arg1 = (Dali::Vector4 *)jarg1;
7326   arg2 = (Dali::Vector4 *)jarg2;
7327   if (!arg2) {
7328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7329     return 0;
7330   }
7331   {
7332     try {
7333       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7334     } catch (std::out_of_range& e) {
7335       {
7336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7337       };
7338     } catch (std::exception& e) {
7339       {
7340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7341       };
7342     } catch (...) {
7343       {
7344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7345       };
7346     }
7347   }
7348   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7349   return jresult;
7350 }
7351
7352
7353 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Length(void * jarg1) {
7354   float jresult ;
7355   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7356   float result;
7357
7358   arg1 = (Dali::Vector4 *)jarg1;
7359   {
7360     try {
7361       result = (float)((Dali::Vector4 const *)arg1)->Length();
7362     } catch (std::out_of_range& e) {
7363       {
7364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7365       };
7366     } catch (std::exception& e) {
7367       {
7368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7369       };
7370     } catch (...) {
7371       {
7372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7373       };
7374     }
7375   }
7376   jresult = result;
7377   return jresult;
7378 }
7379
7380
7381 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_LengthSquared(void * jarg1) {
7382   float jresult ;
7383   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7384   float result;
7385
7386   arg1 = (Dali::Vector4 *)jarg1;
7387   {
7388     try {
7389       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7390     } catch (std::out_of_range& e) {
7391       {
7392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7393       };
7394     } catch (std::exception& e) {
7395       {
7396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7397       };
7398     } catch (...) {
7399       {
7400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7401       };
7402     }
7403   }
7404   jresult = result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Normalize(void * jarg1) {
7410   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7411
7412   arg1 = (Dali::Vector4 *)jarg1;
7413   {
7414     try {
7415       (arg1)->Normalize();
7416     } catch (std::out_of_range& e) {
7417       {
7418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7419       };
7420     } catch (std::exception& e) {
7421       {
7422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7423       };
7424     } catch (...) {
7425       {
7426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7427       };
7428     }
7429   }
7430 }
7431
7432
7433 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7435   Dali::Vector4 *arg2 = 0 ;
7436   Dali::Vector4 *arg3 = 0 ;
7437
7438   arg1 = (Dali::Vector4 *)jarg1;
7439   arg2 = (Dali::Vector4 *)jarg2;
7440   if (!arg2) {
7441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7442     return ;
7443   }
7444   arg3 = (Dali::Vector4 *)jarg3;
7445   if (!arg3) {
7446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7447     return ;
7448   }
7449   {
7450     try {
7451       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7452     } catch (std::out_of_range& e) {
7453       {
7454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7455       };
7456     } catch (std::exception& e) {
7457       {
7458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7459       };
7460     } catch (...) {
7461       {
7462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7463       };
7464     }
7465   }
7466 }
7467
7468
7469 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Vector4_AsFloat__SWIG_0(void * jarg1) {
7470   void * jresult ;
7471   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7472   float *result = 0 ;
7473
7474   arg1 = (Dali::Vector4 *)jarg1;
7475   {
7476     try {
7477       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7478     } catch (std::out_of_range& e) {
7479       {
7480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7481       };
7482     } catch (std::exception& e) {
7483       {
7484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (...) {
7487       {
7488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7489       };
7490     }
7491   }
7492   jresult = (void *)result;
7493   return jresult;
7494 }
7495
7496
7497 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_X_set(void * jarg1, float jarg2) {
7498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7499   float arg2 ;
7500
7501   arg1 = (Dali::Vector4 *)jarg1;
7502   arg2 = (float)jarg2;
7503   if (arg1) (arg1)->x = arg2;
7504 }
7505
7506
7507 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_X_get(void * jarg1) {
7508   float jresult ;
7509   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7510   float result;
7511
7512   arg1 = (Dali::Vector4 *)jarg1;
7513   result = (float) ((arg1)->x);
7514   jresult = result;
7515   return jresult;
7516 }
7517
7518
7519 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_r_set(void * jarg1, float jarg2) {
7520   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7521   float arg2 ;
7522
7523   arg1 = (Dali::Vector4 *)jarg1;
7524   arg2 = (float)jarg2;
7525   if (arg1) (arg1)->r = arg2;
7526 }
7527
7528
7529 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_r_get(void * jarg1) {
7530   float jresult ;
7531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7532   float result;
7533
7534   arg1 = (Dali::Vector4 *)jarg1;
7535   result = (float) ((arg1)->r);
7536   jresult = result;
7537   return jresult;
7538 }
7539
7540
7541 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_s_set(void * jarg1, float jarg2) {
7542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7543   float arg2 ;
7544
7545   arg1 = (Dali::Vector4 *)jarg1;
7546   arg2 = (float)jarg2;
7547   if (arg1) (arg1)->s = arg2;
7548 }
7549
7550
7551 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_s_get(void * jarg1) {
7552   float jresult ;
7553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7554   float result;
7555
7556   arg1 = (Dali::Vector4 *)jarg1;
7557   result = (float) ((arg1)->s);
7558   jresult = result;
7559   return jresult;
7560 }
7561
7562
7563 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Y_set(void * jarg1, float jarg2) {
7564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7565   float arg2 ;
7566
7567   arg1 = (Dali::Vector4 *)jarg1;
7568   arg2 = (float)jarg2;
7569   if (arg1) (arg1)->y = arg2;
7570 }
7571
7572
7573 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Y_get(void * jarg1) {
7574   float jresult ;
7575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7576   float result;
7577
7578   arg1 = (Dali::Vector4 *)jarg1;
7579   result = (float) ((arg1)->y);
7580   jresult = result;
7581   return jresult;
7582 }
7583
7584
7585 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_g_set(void * jarg1, float jarg2) {
7586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7587   float arg2 ;
7588
7589   arg1 = (Dali::Vector4 *)jarg1;
7590   arg2 = (float)jarg2;
7591   if (arg1) (arg1)->g = arg2;
7592 }
7593
7594
7595 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_g_get(void * jarg1) {
7596   float jresult ;
7597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7598   float result;
7599
7600   arg1 = (Dali::Vector4 *)jarg1;
7601   result = (float) ((arg1)->g);
7602   jresult = result;
7603   return jresult;
7604 }
7605
7606
7607 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_t_set(void * jarg1, float jarg2) {
7608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7609   float arg2 ;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   arg2 = (float)jarg2;
7613   if (arg1) (arg1)->t = arg2;
7614 }
7615
7616
7617 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_t_get(void * jarg1) {
7618   float jresult ;
7619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7620   float result;
7621
7622   arg1 = (Dali::Vector4 *)jarg1;
7623   result = (float) ((arg1)->t);
7624   jresult = result;
7625   return jresult;
7626 }
7627
7628
7629 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_Z_set(void * jarg1, float jarg2) {
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   float arg2 ;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   arg2 = (float)jarg2;
7635   if (arg1) (arg1)->z = arg2;
7636 }
7637
7638
7639 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_Z_get(void * jarg1) {
7640   float jresult ;
7641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7642   float result;
7643
7644   arg1 = (Dali::Vector4 *)jarg1;
7645   result = (float) ((arg1)->z);
7646   jresult = result;
7647   return jresult;
7648 }
7649
7650
7651 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_b_set(void * jarg1, float jarg2) {
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   float arg2 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   arg2 = (float)jarg2;
7657   if (arg1) (arg1)->b = arg2;
7658 }
7659
7660
7661 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_b_get(void * jarg1) {
7662   float jresult ;
7663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7664   float result;
7665
7666   arg1 = (Dali::Vector4 *)jarg1;
7667   result = (float) ((arg1)->b);
7668   jresult = result;
7669   return jresult;
7670 }
7671
7672
7673 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_p_set(void * jarg1, float jarg2) {
7674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7675   float arg2 ;
7676
7677   arg1 = (Dali::Vector4 *)jarg1;
7678   arg2 = (float)jarg2;
7679   if (arg1) (arg1)->p = arg2;
7680 }
7681
7682
7683 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_p_get(void * jarg1) {
7684   float jresult ;
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   float result;
7687
7688   arg1 = (Dali::Vector4 *)jarg1;
7689   result = (float) ((arg1)->p);
7690   jresult = result;
7691   return jresult;
7692 }
7693
7694
7695 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_W_set(void * jarg1, float jarg2) {
7696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7697   float arg2 ;
7698
7699   arg1 = (Dali::Vector4 *)jarg1;
7700   arg2 = (float)jarg2;
7701   if (arg1) (arg1)->w = arg2;
7702 }
7703
7704
7705 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_W_get(void * jarg1) {
7706   float jresult ;
7707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7708   float result;
7709
7710   arg1 = (Dali::Vector4 *)jarg1;
7711   result = (float) ((arg1)->w);
7712   jresult = result;
7713   return jresult;
7714 }
7715
7716
7717 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_a_set(void * jarg1, float jarg2) {
7718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7719   float arg2 ;
7720
7721   arg1 = (Dali::Vector4 *)jarg1;
7722   arg2 = (float)jarg2;
7723   if (arg1) (arg1)->a = arg2;
7724 }
7725
7726
7727 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_a_get(void * jarg1) {
7728   float jresult ;
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   float result;
7731
7732   arg1 = (Dali::Vector4 *)jarg1;
7733   result = (float) ((arg1)->a);
7734   jresult = result;
7735   return jresult;
7736 }
7737
7738
7739 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Vector4_q_set(void * jarg1, float jarg2) {
7740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7741   float arg2 ;
7742
7743   arg1 = (Dali::Vector4 *)jarg1;
7744   arg2 = (float)jarg2;
7745   if (arg1) (arg1)->q = arg2;
7746 }
7747
7748
7749 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Vector4_q_get(void * jarg1) {
7750   float jresult ;
7751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7752   float result;
7753
7754   arg1 = (Dali::Vector4 *)jarg1;
7755   result = (float) ((arg1)->q);
7756   jresult = result;
7757   return jresult;
7758 }
7759
7760
7761 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Vector4(void * jarg1) {
7762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7763
7764   arg1 = (Dali::Vector4 *)jarg1;
7765   {
7766     try {
7767       delete arg1;
7768     } catch (std::out_of_range& e) {
7769       {
7770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7771       };
7772     } catch (std::exception& e) {
7773       {
7774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7775       };
7776     } catch (...) {
7777       {
7778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7779       };
7780     }
7781   }
7782 }
7783
7784
7785 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Min__SWIG_2(void * jarg1, void * jarg2) {
7786   void * jresult ;
7787   Dali::Vector4 *arg1 = 0 ;
7788   Dali::Vector4 *arg2 = 0 ;
7789   Dali::Vector4 result;
7790
7791   arg1 = (Dali::Vector4 *)jarg1;
7792   if (!arg1) {
7793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7794     return 0;
7795   }
7796   arg2 = (Dali::Vector4 *)jarg2;
7797   if (!arg2) {
7798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7799     return 0;
7800   }
7801   {
7802     try {
7803       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7804     } catch (std::out_of_range& e) {
7805       {
7806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7807       };
7808     } catch (std::exception& e) {
7809       {
7810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7811       };
7812     } catch (...) {
7813       {
7814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7815       };
7816     }
7817   }
7818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7819   return jresult;
7820 }
7821
7822
7823 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Max__SWIG_2(void * jarg1, void * jarg2) {
7824   void * jresult ;
7825   Dali::Vector4 *arg1 = 0 ;
7826   Dali::Vector4 *arg2 = 0 ;
7827   Dali::Vector4 result;
7828
7829   arg1 = (Dali::Vector4 *)jarg1;
7830   if (!arg1) {
7831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7832     return 0;
7833   }
7834   arg2 = (Dali::Vector4 *)jarg2;
7835   if (!arg2) {
7836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7837     return 0;
7838   }
7839   {
7840     try {
7841       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7842     } catch (std::out_of_range& e) {
7843       {
7844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7845       };
7846     } catch (std::exception& e) {
7847       {
7848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (...) {
7851       {
7852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7853       };
7854     }
7855   }
7856   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7857   return jresult;
7858 }
7859
7860
7861 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7862   void * jresult ;
7863   Dali::Vector4 *arg1 = 0 ;
7864   float *arg2 = 0 ;
7865   float *arg3 = 0 ;
7866   float temp2 ;
7867   float temp3 ;
7868   Dali::Vector4 result;
7869
7870   arg1 = (Dali::Vector4 *)jarg1;
7871   if (!arg1) {
7872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7873     return 0;
7874   }
7875   temp2 = (float)jarg2;
7876   arg2 = &temp2;
7877   temp3 = (float)jarg3;
7878   arg3 = &temp3;
7879   {
7880     try {
7881       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7882     } catch (std::out_of_range& e) {
7883       {
7884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7885       };
7886     } catch (std::exception& e) {
7887       {
7888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7889       };
7890     } catch (...) {
7891       {
7892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7893       };
7894     }
7895   }
7896   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_0() {
7902   void * jresult ;
7903   Dali::Uint16Pair *result = 0 ;
7904
7905   {
7906     try {
7907       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7908     } catch (std::out_of_range& e) {
7909       {
7910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7911       };
7912     } catch (std::exception& e) {
7913       {
7914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7915       };
7916     } catch (...) {
7917       {
7918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7919       };
7920     }
7921   }
7922   jresult = (void *)result;
7923   return jresult;
7924 }
7925
7926
7927 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
7928   void * jresult ;
7929   uint32_t arg1 ;
7930   uint32_t arg2 ;
7931   Dali::Uint16Pair *result = 0 ;
7932
7933   arg1 = (uint32_t)jarg1;
7934   arg2 = (uint32_t)jarg2;
7935   {
7936     try {
7937       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
7938     } catch (std::out_of_range& e) {
7939       {
7940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7941       };
7942     } catch (std::exception& e) {
7943       {
7944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7945       };
7946     } catch (...) {
7947       {
7948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7949       };
7950     }
7951   }
7952   jresult = (void *)result;
7953   return jresult;
7954 }
7955
7956
7957 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Uint16Pair__SWIG_2(void * jarg1) {
7958   void * jresult ;
7959   Dali::Uint16Pair *arg1 = 0 ;
7960   Dali::Uint16Pair *result = 0 ;
7961
7962   arg1 = (Dali::Uint16Pair *)jarg1;
7963   if (!arg1) {
7964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
7965     return 0;
7966   }
7967   {
7968     try {
7969       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
7970     } catch (std::out_of_range& e) {
7971       {
7972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (std::exception& e) {
7975       {
7976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7977       };
7978     } catch (...) {
7979       {
7980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7981       };
7982     }
7983   }
7984   jresult = (void *)result;
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
7990   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
7991   uint16_t arg2 ;
7992
7993   arg1 = (Dali::Uint16Pair *)jarg1;
7994   arg2 = (uint16_t)jarg2;
7995   {
7996     try {
7997       (arg1)->SetWidth(arg2);
7998     } catch (std::out_of_range& e) {
7999       {
8000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8001       };
8002     } catch (std::exception& e) {
8003       {
8004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8005       };
8006     } catch (...) {
8007       {
8008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8009       };
8010     }
8011   }
8012 }
8013
8014
8015 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetWidth(void * jarg1) {
8016   unsigned short jresult ;
8017   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8018   uint16_t result;
8019
8020   arg1 = (Dali::Uint16Pair *)jarg1;
8021   {
8022     try {
8023       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8024     } catch (std::out_of_range& e) {
8025       {
8026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (std::exception& e) {
8029       {
8030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (...) {
8033       {
8034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8035       };
8036     }
8037   }
8038   jresult = result;
8039   return jresult;
8040 }
8041
8042
8043 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8044   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8045   uint16_t arg2 ;
8046
8047   arg1 = (Dali::Uint16Pair *)jarg1;
8048   arg2 = (uint16_t)jarg2;
8049   {
8050     try {
8051       (arg1)->SetHeight(arg2);
8052     } catch (std::out_of_range& e) {
8053       {
8054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8055       };
8056     } catch (std::exception& e) {
8057       {
8058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8059       };
8060     } catch (...) {
8061       {
8062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8063       };
8064     }
8065   }
8066 }
8067
8068
8069 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetHeight(void * jarg1) {
8070   unsigned short jresult ;
8071   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8072   uint16_t result;
8073
8074   arg1 = (Dali::Uint16Pair *)jarg1;
8075   {
8076     try {
8077       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8078     } catch (std::out_of_range& e) {
8079       {
8080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (std::exception& e) {
8083       {
8084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092   jresult = result;
8093   return jresult;
8094 }
8095
8096
8097 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8098   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8099   uint16_t arg2 ;
8100
8101   arg1 = (Dali::Uint16Pair *)jarg1;
8102   arg2 = (uint16_t)jarg2;
8103   {
8104     try {
8105       (arg1)->SetX(arg2);
8106     } catch (std::out_of_range& e) {
8107       {
8108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8109       };
8110     } catch (std::exception& e) {
8111       {
8112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8113       };
8114     } catch (...) {
8115       {
8116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8117       };
8118     }
8119   }
8120 }
8121
8122
8123 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetX(void * jarg1) {
8124   unsigned short jresult ;
8125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8126   uint16_t result;
8127
8128   arg1 = (Dali::Uint16Pair *)jarg1;
8129   {
8130     try {
8131       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8132     } catch (std::out_of_range& e) {
8133       {
8134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8135       };
8136     } catch (std::exception& e) {
8137       {
8138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (...) {
8141       {
8142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8143       };
8144     }
8145   }
8146   jresult = result;
8147   return jresult;
8148 }
8149
8150
8151 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8153   uint16_t arg2 ;
8154
8155   arg1 = (Dali::Uint16Pair *)jarg1;
8156   arg2 = (uint16_t)jarg2;
8157   {
8158     try {
8159       (arg1)->SetY(arg2);
8160     } catch (std::out_of_range& e) {
8161       {
8162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8163       };
8164     } catch (std::exception& e) {
8165       {
8166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8167       };
8168     } catch (...) {
8169       {
8170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8171       };
8172     }
8173   }
8174 }
8175
8176
8177 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_NUI_Uint16Pair_GetY(void * jarg1) {
8178   unsigned short jresult ;
8179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8180   uint16_t result;
8181
8182   arg1 = (Dali::Uint16Pair *)jarg1;
8183   {
8184     try {
8185       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8186     } catch (std::out_of_range& e) {
8187       {
8188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (std::exception& e) {
8191       {
8192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8197       };
8198     }
8199   }
8200   jresult = result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8206   void * jresult ;
8207   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8208   Dali::Uint16Pair *arg2 = 0 ;
8209   Dali::Uint16Pair *result = 0 ;
8210
8211   arg1 = (Dali::Uint16Pair *)jarg1;
8212   arg2 = (Dali::Uint16Pair *)jarg2;
8213   if (!arg2) {
8214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8215     return 0;
8216   }
8217   {
8218     try {
8219       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8220     } catch (std::out_of_range& e) {
8221       {
8222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8223       };
8224     } catch (std::exception& e) {
8225       {
8226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (...) {
8229       {
8230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8231       };
8232     }
8233   }
8234   jresult = (void *)result;
8235   return jresult;
8236 }
8237
8238
8239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8240   unsigned int jresult ;
8241   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8242   Dali::Uint16Pair *arg2 = 0 ;
8243   bool result;
8244
8245   arg1 = (Dali::Uint16Pair *)jarg1;
8246   arg2 = (Dali::Uint16Pair *)jarg2;
8247   if (!arg2) {
8248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8249     return 0;
8250   }
8251   {
8252     try {
8253       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8254     } catch (std::out_of_range& e) {
8255       {
8256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8257       };
8258     } catch (std::exception& e) {
8259       {
8260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8261       };
8262     } catch (...) {
8263       {
8264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8265       };
8266     }
8267   }
8268   jresult = result;
8269   return jresult;
8270 }
8271
8272
8273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8274   unsigned int jresult ;
8275   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8276   Dali::Uint16Pair *arg2 = 0 ;
8277   bool result;
8278
8279   arg1 = (Dali::Uint16Pair *)jarg1;
8280   arg2 = (Dali::Uint16Pair *)jarg2;
8281   if (!arg2) {
8282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8283     return 0;
8284   }
8285   {
8286     try {
8287       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8295       };
8296     } catch (...) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8299       };
8300     }
8301   }
8302   jresult = result;
8303   return jresult;
8304 }
8305
8306
8307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8308   unsigned int jresult ;
8309   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8310   Dali::Uint16Pair *arg2 = 0 ;
8311   bool result;
8312
8313   arg1 = (Dali::Uint16Pair *)jarg1;
8314   arg2 = (Dali::Uint16Pair *)jarg2;
8315   if (!arg2) {
8316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8317     return 0;
8318   }
8319   {
8320     try {
8321       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8322     } catch (std::out_of_range& e) {
8323       {
8324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8325       };
8326     } catch (std::exception& e) {
8327       {
8328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8329       };
8330     } catch (...) {
8331       {
8332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8333       };
8334     }
8335   }
8336   jresult = result;
8337   return jresult;
8338 }
8339
8340
8341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8342   unsigned int jresult ;
8343   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8344   Dali::Uint16Pair *arg2 = 0 ;
8345   bool result;
8346
8347   arg1 = (Dali::Uint16Pair *)jarg1;
8348   arg2 = (Dali::Uint16Pair *)jarg2;
8349   if (!arg2) {
8350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8351     return 0;
8352   }
8353   {
8354     try {
8355       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8356     } catch (std::out_of_range& e) {
8357       {
8358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8359       };
8360     } catch (std::exception& e) {
8361       {
8362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8363       };
8364     } catch (...) {
8365       {
8366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8367       };
8368     }
8369   }
8370   jresult = result;
8371   return jresult;
8372 }
8373
8374
8375 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Uint16Pair(void * jarg1) {
8376   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8377
8378   arg1 = (Dali::Uint16Pair *)jarg1;
8379   {
8380     try {
8381       delete arg1;
8382     } catch (std::out_of_range& e) {
8383       {
8384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8385       };
8386     } catch (std::exception& e) {
8387       {
8388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8389       };
8390     } catch (...) {
8391       {
8392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8393       };
8394     }
8395   }
8396 }
8397
8398
8399 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_0() {
8400   void * jresult ;
8401   Dali::Degree *result = 0 ;
8402
8403   {
8404     try {
8405       result = (Dali::Degree *)new Dali::Degree();
8406     } catch (std::out_of_range& e) {
8407       {
8408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (std::exception& e) {
8411       {
8412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8413       };
8414     } catch (...) {
8415       {
8416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8417       };
8418     }
8419   }
8420   jresult = (void *)result;
8421   return jresult;
8422 }
8423
8424
8425 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_1(float jarg1) {
8426   void * jresult ;
8427   float arg1 ;
8428   Dali::Degree *result = 0 ;
8429
8430   arg1 = (float)jarg1;
8431   {
8432     try {
8433       result = (Dali::Degree *)new Dali::Degree(arg1);
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8441       };
8442     } catch (...) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8445       };
8446     }
8447   }
8448   jresult = (void *)result;
8449   return jresult;
8450 }
8451
8452
8453 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Degree__SWIG_2(void * jarg1) {
8454   void * jresult ;
8455   Dali::Radian arg1 ;
8456   Dali::Radian *argp1 ;
8457   Dali::Degree *result = 0 ;
8458
8459   argp1 = (Dali::Radian *)jarg1;
8460   if (!argp1) {
8461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8462     return 0;
8463   }
8464   arg1 = *argp1;
8465   {
8466     try {
8467       result = (Dali::Degree *)new Dali::Degree(arg1);
8468     } catch (std::out_of_range& e) {
8469       {
8470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8471       };
8472     } catch (std::exception& e) {
8473       {
8474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8475       };
8476     } catch (...) {
8477       {
8478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8479       };
8480     }
8481   }
8482   jresult = (void *)result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Degree_degree_set(void * jarg1, float jarg2) {
8488   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8489   float arg2 ;
8490
8491   arg1 = (Dali::Degree *)jarg1;
8492   arg2 = (float)jarg2;
8493   if (arg1) (arg1)->degree = arg2;
8494 }
8495
8496
8497 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Degree_degree_get(void * jarg1) {
8498   float jresult ;
8499   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8500   float result;
8501
8502   arg1 = (Dali::Degree *)jarg1;
8503   result = (float) ((arg1)->degree);
8504   jresult = result;
8505   return jresult;
8506 }
8507
8508
8509 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Degree(void * jarg1) {
8510   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8511
8512   arg1 = (Dali::Degree *)jarg1;
8513   {
8514     try {
8515       delete arg1;
8516     } catch (std::out_of_range& e) {
8517       {
8518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8519       };
8520     } catch (std::exception& e) {
8521       {
8522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8527       };
8528     }
8529   }
8530 }
8531
8532
8533 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_360_get() {
8534   void * jresult ;
8535   Dali::Radian *result = 0 ;
8536
8537   result = (Dali::Radian *)&Dali::ANGLE_360;
8538   jresult = (void *)result;
8539   return jresult;
8540 }
8541
8542
8543 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_315_get() {
8544   void * jresult ;
8545   Dali::Radian *result = 0 ;
8546
8547   result = (Dali::Radian *)&Dali::ANGLE_315;
8548   jresult = (void *)result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_270_get() {
8554   void * jresult ;
8555   Dali::Radian *result = 0 ;
8556
8557   result = (Dali::Radian *)&Dali::ANGLE_270;
8558   jresult = (void *)result;
8559   return jresult;
8560 }
8561
8562
8563 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_225_get() {
8564   void * jresult ;
8565   Dali::Radian *result = 0 ;
8566
8567   result = (Dali::Radian *)&Dali::ANGLE_225;
8568   jresult = (void *)result;
8569   return jresult;
8570 }
8571
8572
8573 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_180_get() {
8574   void * jresult ;
8575   Dali::Radian *result = 0 ;
8576
8577   result = (Dali::Radian *)&Dali::ANGLE_180;
8578   jresult = (void *)result;
8579   return jresult;
8580 }
8581
8582
8583 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_135_get() {
8584   void * jresult ;
8585   Dali::Radian *result = 0 ;
8586
8587   result = (Dali::Radian *)&Dali::ANGLE_135;
8588   jresult = (void *)result;
8589   return jresult;
8590 }
8591
8592
8593 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_120_get() {
8594   void * jresult ;
8595   Dali::Radian *result = 0 ;
8596
8597   result = (Dali::Radian *)&Dali::ANGLE_120;
8598   jresult = (void *)result;
8599   return jresult;
8600 }
8601
8602
8603 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_90_get() {
8604   void * jresult ;
8605   Dali::Radian *result = 0 ;
8606
8607   result = (Dali::Radian *)&Dali::ANGLE_90;
8608   jresult = (void *)result;
8609   return jresult;
8610 }
8611
8612
8613 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_60_get() {
8614   void * jresult ;
8615   Dali::Radian *result = 0 ;
8616
8617   result = (Dali::Radian *)&Dali::ANGLE_60;
8618   jresult = (void *)result;
8619   return jresult;
8620 }
8621
8622
8623 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_45_get() {
8624   void * jresult ;
8625   Dali::Radian *result = 0 ;
8626
8627   result = (Dali::Radian *)&Dali::ANGLE_45;
8628   jresult = (void *)result;
8629   return jresult;
8630 }
8631
8632
8633 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_30_get() {
8634   void * jresult ;
8635   Dali::Radian *result = 0 ;
8636
8637   result = (Dali::Radian *)&Dali::ANGLE_30;
8638   jresult = (void *)result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ANGLE_0_get() {
8644   void * jresult ;
8645   Dali::Radian *result = 0 ;
8646
8647   result = (Dali::Radian *)&Dali::ANGLE_0;
8648   jresult = (void *)result;
8649   return jresult;
8650 }
8651
8652
8653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8654   unsigned int jresult ;
8655   Dali::Degree *arg1 = 0 ;
8656   Dali::Degree *arg2 = 0 ;
8657   bool result;
8658
8659   arg1 = (Dali::Degree *)jarg1;
8660   if (!arg1) {
8661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8662     return 0;
8663   }
8664   arg2 = (Dali::Degree *)jarg2;
8665   if (!arg2) {
8666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8667     return 0;
8668   }
8669   {
8670     try {
8671       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8672     } catch (std::out_of_range& e) {
8673       {
8674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8675       };
8676     } catch (std::exception& e) {
8677       {
8678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8679       };
8680     } catch (...) {
8681       {
8682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8683       };
8684     }
8685   }
8686   jresult = result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8692   unsigned int jresult ;
8693   Dali::Degree *arg1 = 0 ;
8694   Dali::Degree *arg2 = 0 ;
8695   bool result;
8696
8697   arg1 = (Dali::Degree *)jarg1;
8698   if (!arg1) {
8699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8700     return 0;
8701   }
8702   arg2 = (Dali::Degree *)jarg2;
8703   if (!arg2) {
8704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8705     return 0;
8706   }
8707   {
8708     try {
8709       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8710     } catch (std::out_of_range& e) {
8711       {
8712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8713       };
8714     } catch (std::exception& e) {
8715       {
8716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8717       };
8718     } catch (...) {
8719       {
8720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8721       };
8722     }
8723   }
8724   jresult = result;
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8730   void * jresult ;
8731   Dali::Degree arg1 ;
8732   float arg2 ;
8733   float arg3 ;
8734   Dali::Degree *argp1 ;
8735   Dali::Degree result;
8736
8737   argp1 = (Dali::Degree *)jarg1;
8738   if (!argp1) {
8739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8740     return 0;
8741   }
8742   arg1 = *argp1;
8743   arg2 = (float)jarg2;
8744   arg3 = (float)jarg3;
8745   {
8746     try {
8747       result = Dali::Clamp(arg1,arg2,arg3);
8748     } catch (std::out_of_range& e) {
8749       {
8750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8751       };
8752     } catch (std::exception& e) {
8753       {
8754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8755       };
8756     } catch (...) {
8757       {
8758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8759       };
8760     }
8761   }
8762   jresult = new Dali::Degree((const Dali::Degree &)result);
8763   return jresult;
8764 }
8765
8766
8767 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_0() {
8768   void * jresult ;
8769   Dali::Radian *result = 0 ;
8770
8771   {
8772     try {
8773       result = (Dali::Radian *)new Dali::Radian();
8774     } catch (std::out_of_range& e) {
8775       {
8776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8777       };
8778     } catch (std::exception& e) {
8779       {
8780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8781       };
8782     } catch (...) {
8783       {
8784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8785       };
8786     }
8787   }
8788   jresult = (void *)result;
8789   return jresult;
8790 }
8791
8792
8793 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_1(float jarg1) {
8794   void * jresult ;
8795   float arg1 ;
8796   Dali::Radian *result = 0 ;
8797
8798   arg1 = (float)jarg1;
8799   {
8800     try {
8801       result = (Dali::Radian *)new Dali::Radian(arg1);
8802     } catch (std::out_of_range& e) {
8803       {
8804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8805       };
8806     } catch (std::exception& e) {
8807       {
8808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8809       };
8810     } catch (...) {
8811       {
8812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8813       };
8814     }
8815   }
8816   jresult = (void *)result;
8817   return jresult;
8818 }
8819
8820
8821 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Radian__SWIG_2(void * jarg1) {
8822   void * jresult ;
8823   Dali::Degree arg1 ;
8824   Dali::Degree *argp1 ;
8825   Dali::Radian *result = 0 ;
8826
8827   argp1 = (Dali::Degree *)jarg1;
8828   if (!argp1) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8830     return 0;
8831   }
8832   arg1 = *argp1;
8833   {
8834     try {
8835       result = (Dali::Radian *)new Dali::Radian(arg1);
8836     } catch (std::out_of_range& e) {
8837       {
8838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8839       };
8840     } catch (std::exception& e) {
8841       {
8842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8843       };
8844     } catch (...) {
8845       {
8846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8847       };
8848     }
8849   }
8850   jresult = (void *)result;
8851   return jresult;
8852 }
8853
8854
8855 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8856   void * jresult ;
8857   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8858   float arg2 ;
8859   Dali::Radian *result = 0 ;
8860
8861   arg1 = (Dali::Radian *)jarg1;
8862   arg2 = (float)jarg2;
8863   {
8864     try {
8865       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8866     } catch (std::out_of_range& e) {
8867       {
8868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8869       };
8870     } catch (std::exception& e) {
8871       {
8872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8873       };
8874     } catch (...) {
8875       {
8876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8877       };
8878     }
8879   }
8880   jresult = (void *)result;
8881   return jresult;
8882 }
8883
8884
8885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8886   void * jresult ;
8887   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8888   Dali::Degree arg2 ;
8889   Dali::Degree *argp2 ;
8890   Dali::Radian *result = 0 ;
8891
8892   arg1 = (Dali::Radian *)jarg1;
8893   argp2 = (Dali::Degree *)jarg2;
8894   if (!argp2) {
8895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8896     return 0;
8897   }
8898   arg2 = *argp2;
8899   {
8900     try {
8901       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8902     } catch (std::out_of_range& e) {
8903       {
8904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8905       };
8906     } catch (std::exception& e) {
8907       {
8908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8909       };
8910     } catch (...) {
8911       {
8912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8913       };
8914     }
8915   }
8916   jresult = (void *)result;
8917   return jresult;
8918 }
8919
8920
8921 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Radian_ConvertToFloat(void * jarg1) {
8922   float jresult ;
8923   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8924   float result;
8925
8926   arg1 = (Dali::Radian *)jarg1;
8927   {
8928     try {
8929       result = (float)((Dali::Radian const *)arg1)->operator float();
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (...) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8941       };
8942     }
8943   }
8944   jresult = result;
8945   return jresult;
8946 }
8947
8948
8949 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Radian_radian_set(void * jarg1, float jarg2) {
8950   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8951   float arg2 ;
8952
8953   arg1 = (Dali::Radian *)jarg1;
8954   arg2 = (float)jarg2;
8955   if (arg1) (arg1)->radian = arg2;
8956 }
8957
8958
8959 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Radian_radian_get(void * jarg1) {
8960   float jresult ;
8961   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8962   float result;
8963
8964   arg1 = (Dali::Radian *)jarg1;
8965   result = (float) ((arg1)->radian);
8966   jresult = result;
8967   return jresult;
8968 }
8969
8970
8971 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Radian(void * jarg1) {
8972   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8973
8974   arg1 = (Dali::Radian *)jarg1;
8975   {
8976     try {
8977       delete arg1;
8978     } catch (std::out_of_range& e) {
8979       {
8980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8981       };
8982     } catch (std::exception& e) {
8983       {
8984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8985       };
8986     } catch (...) {
8987       {
8988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8989       };
8990     }
8991   }
8992 }
8993
8994
8995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
8996   unsigned int jresult ;
8997   Dali::Radian arg1 ;
8998   Dali::Radian arg2 ;
8999   Dali::Radian *argp1 ;
9000   Dali::Radian *argp2 ;
9001   bool result;
9002
9003   argp1 = (Dali::Radian *)jarg1;
9004   if (!argp1) {
9005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9006     return 0;
9007   }
9008   arg1 = *argp1;
9009   argp2 = (Dali::Radian *)jarg2;
9010   if (!argp2) {
9011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9012     return 0;
9013   }
9014   arg2 = *argp2;
9015   {
9016     try {
9017       result = (bool)Dali::operator ==(arg1,arg2);
9018     } catch (std::out_of_range& e) {
9019       {
9020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9021       };
9022     } catch (std::exception& e) {
9023       {
9024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9025       };
9026     } catch (...) {
9027       {
9028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9029       };
9030     }
9031   }
9032   jresult = result;
9033   return jresult;
9034 }
9035
9036
9037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9038   unsigned int jresult ;
9039   Dali::Radian arg1 ;
9040   Dali::Radian arg2 ;
9041   Dali::Radian *argp1 ;
9042   Dali::Radian *argp2 ;
9043   bool result;
9044
9045   argp1 = (Dali::Radian *)jarg1;
9046   if (!argp1) {
9047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9048     return 0;
9049   }
9050   arg1 = *argp1;
9051   argp2 = (Dali::Radian *)jarg2;
9052   if (!argp2) {
9053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9054     return 0;
9055   }
9056   arg2 = *argp2;
9057   {
9058     try {
9059       result = (bool)Dali::operator !=(arg1,arg2);
9060     } catch (std::out_of_range& e) {
9061       {
9062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9063       };
9064     } catch (std::exception& e) {
9065       {
9066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9071       };
9072     }
9073   }
9074   jresult = result;
9075   return jresult;
9076 }
9077
9078
9079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9080   unsigned int jresult ;
9081   Dali::Radian arg1 ;
9082   Dali::Degree arg2 ;
9083   Dali::Radian *argp1 ;
9084   Dali::Degree *argp2 ;
9085   bool result;
9086
9087   argp1 = (Dali::Radian *)jarg1;
9088   if (!argp1) {
9089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9090     return 0;
9091   }
9092   arg1 = *argp1;
9093   argp2 = (Dali::Degree *)jarg2;
9094   if (!argp2) {
9095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9096     return 0;
9097   }
9098   arg2 = *argp2;
9099   {
9100     try {
9101       result = (bool)Dali::operator ==(arg1,arg2);
9102     } catch (std::out_of_range& e) {
9103       {
9104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9105       };
9106     } catch (std::exception& e) {
9107       {
9108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9109       };
9110     } catch (...) {
9111       {
9112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9113       };
9114     }
9115   }
9116   jresult = result;
9117   return jresult;
9118 }
9119
9120
9121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9122   unsigned int jresult ;
9123   Dali::Radian arg1 ;
9124   Dali::Degree arg2 ;
9125   Dali::Radian *argp1 ;
9126   Dali::Degree *argp2 ;
9127   bool result;
9128
9129   argp1 = (Dali::Radian *)jarg1;
9130   if (!argp1) {
9131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9132     return 0;
9133   }
9134   arg1 = *argp1;
9135   argp2 = (Dali::Degree *)jarg2;
9136   if (!argp2) {
9137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9138     return 0;
9139   }
9140   arg2 = *argp2;
9141   {
9142     try {
9143       result = (bool)Dali::operator !=(arg1,arg2);
9144     } catch (std::out_of_range& e) {
9145       {
9146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9147       };
9148     } catch (std::exception& e) {
9149       {
9150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9151       };
9152     } catch (...) {
9153       {
9154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9155       };
9156     }
9157   }
9158   jresult = result;
9159   return jresult;
9160 }
9161
9162
9163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9164   unsigned int jresult ;
9165   Dali::Degree arg1 ;
9166   Dali::Radian arg2 ;
9167   Dali::Degree *argp1 ;
9168   Dali::Radian *argp2 ;
9169   bool result;
9170
9171   argp1 = (Dali::Degree *)jarg1;
9172   if (!argp1) {
9173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9174     return 0;
9175   }
9176   arg1 = *argp1;
9177   argp2 = (Dali::Radian *)jarg2;
9178   if (!argp2) {
9179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9180     return 0;
9181   }
9182   arg2 = *argp2;
9183   {
9184     try {
9185       result = (bool)Dali::operator ==(arg1,arg2);
9186     } catch (std::out_of_range& e) {
9187       {
9188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9189       };
9190     } catch (std::exception& e) {
9191       {
9192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9193       };
9194     } catch (...) {
9195       {
9196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9197       };
9198     }
9199   }
9200   jresult = result;
9201   return jresult;
9202 }
9203
9204
9205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9206   unsigned int jresult ;
9207   Dali::Degree arg1 ;
9208   Dali::Radian arg2 ;
9209   Dali::Degree *argp1 ;
9210   Dali::Radian *argp2 ;
9211   bool result;
9212
9213   argp1 = (Dali::Degree *)jarg1;
9214   if (!argp1) {
9215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9216     return 0;
9217   }
9218   arg1 = *argp1;
9219   argp2 = (Dali::Radian *)jarg2;
9220   if (!argp2) {
9221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9222     return 0;
9223   }
9224   arg2 = *argp2;
9225   {
9226     try {
9227       result = (bool)Dali::operator !=(arg1,arg2);
9228     } catch (std::out_of_range& e) {
9229       {
9230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (std::exception& e) {
9233       {
9234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9235       };
9236     } catch (...) {
9237       {
9238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9239       };
9240     }
9241   }
9242   jresult = result;
9243   return jresult;
9244 }
9245
9246
9247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9248   unsigned int jresult ;
9249   Dali::Radian arg1 ;
9250   Dali::Radian arg2 ;
9251   Dali::Radian *argp1 ;
9252   Dali::Radian *argp2 ;
9253   bool result;
9254
9255   argp1 = (Dali::Radian *)jarg1;
9256   if (!argp1) {
9257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9258     return 0;
9259   }
9260   arg1 = *argp1;
9261   argp2 = (Dali::Radian *)jarg2;
9262   if (!argp2) {
9263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9264     return 0;
9265   }
9266   arg2 = *argp2;
9267   {
9268     try {
9269       result = (bool)Dali::operator >(arg1,arg2);
9270     } catch (std::out_of_range& e) {
9271       {
9272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9273       };
9274     } catch (std::exception& e) {
9275       {
9276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9277       };
9278     } catch (...) {
9279       {
9280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9281       };
9282     }
9283   }
9284   jresult = result;
9285   return jresult;
9286 }
9287
9288
9289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9290   unsigned int jresult ;
9291   Dali::Radian arg1 ;
9292   Dali::Degree arg2 ;
9293   Dali::Radian *argp1 ;
9294   Dali::Degree *argp2 ;
9295   bool result;
9296
9297   argp1 = (Dali::Radian *)jarg1;
9298   if (!argp1) {
9299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9300     return 0;
9301   }
9302   arg1 = *argp1;
9303   argp2 = (Dali::Degree *)jarg2;
9304   if (!argp2) {
9305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9306     return 0;
9307   }
9308   arg2 = *argp2;
9309   {
9310     try {
9311       result = (bool)Dali::operator >(arg1,arg2);
9312     } catch (std::out_of_range& e) {
9313       {
9314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9315       };
9316     } catch (std::exception& e) {
9317       {
9318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9319       };
9320     } catch (...) {
9321       {
9322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9323       };
9324     }
9325   }
9326   jresult = result;
9327   return jresult;
9328 }
9329
9330
9331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9332   unsigned int jresult ;
9333   Dali::Degree arg1 ;
9334   Dali::Radian arg2 ;
9335   Dali::Degree *argp1 ;
9336   Dali::Radian *argp2 ;
9337   bool result;
9338
9339   argp1 = (Dali::Degree *)jarg1;
9340   if (!argp1) {
9341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9342     return 0;
9343   }
9344   arg1 = *argp1;
9345   argp2 = (Dali::Radian *)jarg2;
9346   if (!argp2) {
9347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9348     return 0;
9349   }
9350   arg2 = *argp2;
9351   {
9352     try {
9353       result = (bool)Dali::operator >(arg1,arg2);
9354     } catch (std::out_of_range& e) {
9355       {
9356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9357       };
9358     } catch (std::exception& e) {
9359       {
9360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9361       };
9362     } catch (...) {
9363       {
9364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9365       };
9366     }
9367   }
9368   jresult = result;
9369   return jresult;
9370 }
9371
9372
9373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9374   unsigned int jresult ;
9375   Dali::Radian arg1 ;
9376   Dali::Radian arg2 ;
9377   Dali::Radian *argp1 ;
9378   Dali::Radian *argp2 ;
9379   bool result;
9380
9381   argp1 = (Dali::Radian *)jarg1;
9382   if (!argp1) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9384     return 0;
9385   }
9386   arg1 = *argp1;
9387   argp2 = (Dali::Radian *)jarg2;
9388   if (!argp2) {
9389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9390     return 0;
9391   }
9392   arg2 = *argp2;
9393   {
9394     try {
9395       result = (bool)Dali::operator <(arg1,arg2);
9396     } catch (std::out_of_range& e) {
9397       {
9398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9399       };
9400     } catch (std::exception& e) {
9401       {
9402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9403       };
9404     } catch (...) {
9405       {
9406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9407       };
9408     }
9409   }
9410   jresult = result;
9411   return jresult;
9412 }
9413
9414
9415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9416   unsigned int jresult ;
9417   Dali::Radian arg1 ;
9418   Dali::Degree arg2 ;
9419   Dali::Radian *argp1 ;
9420   Dali::Degree *argp2 ;
9421   bool result;
9422
9423   argp1 = (Dali::Radian *)jarg1;
9424   if (!argp1) {
9425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9426     return 0;
9427   }
9428   arg1 = *argp1;
9429   argp2 = (Dali::Degree *)jarg2;
9430   if (!argp2) {
9431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9432     return 0;
9433   }
9434   arg2 = *argp2;
9435   {
9436     try {
9437       result = (bool)Dali::operator <(arg1,arg2);
9438     } catch (std::out_of_range& e) {
9439       {
9440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9441       };
9442     } catch (std::exception& e) {
9443       {
9444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9445       };
9446     } catch (...) {
9447       {
9448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9449       };
9450     }
9451   }
9452   jresult = result;
9453   return jresult;
9454 }
9455
9456
9457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9458   unsigned int jresult ;
9459   Dali::Degree arg1 ;
9460   Dali::Radian arg2 ;
9461   Dali::Degree *argp1 ;
9462   Dali::Radian *argp2 ;
9463   bool result;
9464
9465   argp1 = (Dali::Degree *)jarg1;
9466   if (!argp1) {
9467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9468     return 0;
9469   }
9470   arg1 = *argp1;
9471   argp2 = (Dali::Radian *)jarg2;
9472   if (!argp2) {
9473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9474     return 0;
9475   }
9476   arg2 = *argp2;
9477   {
9478     try {
9479       result = (bool)Dali::operator <(arg1,arg2);
9480     } catch (std::out_of_range& e) {
9481       {
9482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9483       };
9484     } catch (std::exception& e) {
9485       {
9486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9487       };
9488     } catch (...) {
9489       {
9490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9491       };
9492     }
9493   }
9494   jresult = result;
9495   return jresult;
9496 }
9497
9498
9499 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Multiply(void * jarg1, float jarg2) {
9500   void * jresult ;
9501   Dali::Radian arg1 ;
9502   float arg2 ;
9503   Dali::Radian *argp1 ;
9504   Dali::Radian result;
9505
9506   argp1 = (Dali::Radian *)jarg1;
9507   if (!argp1) {
9508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9509     return 0;
9510   }
9511   arg1 = *argp1;
9512   arg2 = (float)jarg2;
9513   {
9514     try {
9515       result = Dali::operator *(arg1,arg2);
9516     } catch (std::out_of_range& e) {
9517       {
9518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9519       };
9520     } catch (std::exception& e) {
9521       {
9522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9523       };
9524     } catch (...) {
9525       {
9526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9527       };
9528     }
9529   }
9530   jresult = new Dali::Radian((const Dali::Radian &)result);
9531   return jresult;
9532 }
9533
9534
9535 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Subtract(void * jarg1) {
9536   void * jresult ;
9537   Dali::Radian arg1 ;
9538   Dali::Radian *argp1 ;
9539   Dali::Radian result;
9540
9541   argp1 = (Dali::Radian *)jarg1;
9542   if (!argp1) {
9543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9544     return 0;
9545   }
9546   arg1 = *argp1;
9547   {
9548     try {
9549       result = Dali::operator -(arg1);
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (...) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9561       };
9562     }
9563   }
9564   jresult = new Dali::Radian((const Dali::Radian &)result);
9565   return jresult;
9566 }
9567
9568
9569 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9570   void * jresult ;
9571   Dali::Radian arg1 ;
9572   float arg2 ;
9573   float arg3 ;
9574   Dali::Radian *argp1 ;
9575   Dali::Radian result;
9576
9577   argp1 = (Dali::Radian *)jarg1;
9578   if (!argp1) {
9579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9580     return 0;
9581   }
9582   arg1 = *argp1;
9583   arg2 = (float)jarg2;
9584   arg3 = (float)jarg3;
9585   {
9586     try {
9587       result = Dali::Clamp(arg1,arg2,arg3);
9588     } catch (std::out_of_range& e) {
9589       {
9590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9591       };
9592     } catch (std::exception& e) {
9593       {
9594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9595       };
9596     } catch (...) {
9597       {
9598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9599       };
9600     }
9601   }
9602   jresult = new Dali::Radian((const Dali::Radian &)result);
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_0() {
9608   void * jresult ;
9609   Dali::Quaternion *result = 0 ;
9610
9611   {
9612     try {
9613       result = (Dali::Quaternion *)new Dali::Quaternion();
9614     } catch (std::out_of_range& e) {
9615       {
9616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9617       };
9618     } catch (std::exception& e) {
9619       {
9620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (...) {
9623       {
9624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9625       };
9626     }
9627   }
9628   jresult = (void *)result;
9629   return jresult;
9630 }
9631
9632
9633 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
9634   void * jresult ;
9635   float arg1 ;
9636   float arg2 ;
9637   float arg3 ;
9638   float arg4 ;
9639   Dali::Quaternion *result = 0 ;
9640
9641   arg1 = (float)jarg1;
9642   arg2 = (float)jarg2;
9643   arg3 = (float)jarg3;
9644   arg4 = (float)jarg4;
9645   {
9646     try {
9647       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3,arg4);
9648     } catch (std::out_of_range& e) {
9649       {
9650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9651       };
9652     } catch (std::exception& e) {
9653       {
9654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9655       };
9656     } catch (...) {
9657       {
9658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9659       };
9660     }
9661   }
9662   jresult = (void *)result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_2(void * jarg1) {
9668   void * jresult ;
9669   Dali::Vector4 *arg1 = 0 ;
9670   Dali::Quaternion *result = 0 ;
9671
9672   arg1 = (Dali::Vector4 *)jarg1;
9673   if (!arg1) {
9674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
9675     return 0;
9676   }
9677   {
9678     try {
9679       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector4 const &)*arg1);
9680     } catch (std::out_of_range& e) {
9681       {
9682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9683       };
9684     } catch (std::exception& e) {
9685       {
9686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9687       };
9688     } catch (...) {
9689       {
9690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9691       };
9692     }
9693   }
9694   jresult = (void *)result;
9695   return jresult;
9696 }
9697
9698
9699 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_3(void * jarg1, void * jarg2) {
9700   void * jresult ;
9701   Dali::Radian arg1 ;
9702   Dali::Vector3 *arg2 = 0 ;
9703   Dali::Radian *argp1 ;
9704   Dali::Quaternion *result = 0 ;
9705
9706   argp1 = (Dali::Radian *)jarg1;
9707   if (!argp1) {
9708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9709     return 0;
9710   }
9711   arg1 = *argp1;
9712   arg2 = (Dali::Vector3 *)jarg2;
9713   if (!arg2) {
9714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9715     return 0;
9716   }
9717   {
9718     try {
9719       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9720     } catch (std::out_of_range& e) {
9721       {
9722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9723       };
9724     } catch (std::exception& e) {
9725       {
9726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9727       };
9728     } catch (...) {
9729       {
9730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9731       };
9732     }
9733   }
9734   jresult = (void *)result;
9735   return jresult;
9736 }
9737
9738
9739 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
9740   void * jresult ;
9741   Dali::Radian arg1 ;
9742   Dali::Radian arg2 ;
9743   Dali::Radian arg3 ;
9744   Dali::Radian *argp1 ;
9745   Dali::Radian *argp2 ;
9746   Dali::Radian *argp3 ;
9747   Dali::Quaternion *result = 0 ;
9748
9749   argp1 = (Dali::Radian *)jarg1;
9750   if (!argp1) {
9751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9752     return 0;
9753   }
9754   arg1 = *argp1;
9755   argp2 = (Dali::Radian *)jarg2;
9756   if (!argp2) {
9757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9758     return 0;
9759   }
9760   arg2 = *argp2;
9761   argp3 = (Dali::Radian *)jarg3;
9762   if (!argp3) {
9763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9764     return 0;
9765   }
9766   arg3 = *argp3;
9767   {
9768     try {
9769       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3);
9770     } catch (std::out_of_range& e) {
9771       {
9772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9773       };
9774     } catch (std::exception& e) {
9775       {
9776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9777       };
9778     } catch (...) {
9779       {
9780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9781       };
9782     }
9783   }
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_5(void * jarg1) {
9790   void * jresult ;
9791   Dali::Matrix *arg1 = 0 ;
9792   Dali::Quaternion *result = 0 ;
9793
9794   arg1 = (Dali::Matrix *)jarg1;
9795   if (!arg1) {
9796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9797     return 0;
9798   }
9799   {
9800     try {
9801       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Matrix const &)*arg1);
9802     } catch (std::out_of_range& e) {
9803       {
9804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9805       };
9806     } catch (std::exception& e) {
9807       {
9808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9809       };
9810     } catch (...) {
9811       {
9812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9813       };
9814     }
9815   }
9816   jresult = (void *)result;
9817   return jresult;
9818 }
9819
9820
9821 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
9822   void * jresult ;
9823   Dali::Vector3 *arg1 = 0 ;
9824   Dali::Vector3 *arg2 = 0 ;
9825   Dali::Vector3 *arg3 = 0 ;
9826   Dali::Quaternion *result = 0 ;
9827
9828   arg1 = (Dali::Vector3 *)jarg1;
9829   if (!arg1) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9831     return 0;
9832   }
9833   arg2 = (Dali::Vector3 *)jarg2;
9834   if (!arg2) {
9835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9836     return 0;
9837   }
9838   arg3 = (Dali::Vector3 *)jarg3;
9839   if (!arg3) {
9840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9841     return 0;
9842   }
9843   {
9844     try {
9845       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
9846     } catch (std::out_of_range& e) {
9847       {
9848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9849       };
9850     } catch (std::exception& e) {
9851       {
9852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9853       };
9854     } catch (...) {
9855       {
9856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9857       };
9858     }
9859   }
9860   jresult = (void *)result;
9861   return jresult;
9862 }
9863
9864
9865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Quaternion__SWIG_7(void * jarg1, void * jarg2) {
9866   void * jresult ;
9867   Dali::Vector3 *arg1 = 0 ;
9868   Dali::Vector3 *arg2 = 0 ;
9869   Dali::Quaternion *result = 0 ;
9870
9871   arg1 = (Dali::Vector3 *)jarg1;
9872   if (!arg1) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9874     return 0;
9875   }
9876   arg2 = (Dali::Vector3 *)jarg2;
9877   if (!arg2) {
9878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9879     return 0;
9880   }
9881   {
9882     try {
9883       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
9884     } catch (std::out_of_range& e) {
9885       {
9886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9887       };
9888     } catch (std::exception& e) {
9889       {
9890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9891       };
9892     } catch (...) {
9893       {
9894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9895       };
9896     }
9897   }
9898   jresult = (void *)result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Quaternion(void * jarg1) {
9904   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9905
9906   arg1 = (Dali::Quaternion *)jarg1;
9907   {
9908     try {
9909       delete arg1;
9910     } catch (std::out_of_range& e) {
9911       {
9912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9913       };
9914     } catch (std::exception& e) {
9915       {
9916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9917       };
9918     } catch (...) {
9919       {
9920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9921       };
9922     }
9923   }
9924 }
9925
9926
9927 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_IDENTITY_get() {
9928   void * jresult ;
9929   Dali::Quaternion *result = 0 ;
9930
9931   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9932   jresult = (void *)result;
9933   return jresult;
9934 }
9935
9936
9937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_IsIdentity(void * jarg1) {
9938   unsigned int jresult ;
9939   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9940   bool result;
9941
9942   arg1 = (Dali::Quaternion *)jarg1;
9943   {
9944     try {
9945       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9946     } catch (std::out_of_range& e) {
9947       {
9948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9949       };
9950     } catch (std::exception& e) {
9951       {
9952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9953       };
9954     } catch (...) {
9955       {
9956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9957       };
9958     }
9959   }
9960   jresult = result;
9961   return jresult;
9962 }
9963
9964
9965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_ToAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9966   unsigned int jresult ;
9967   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9968   Dali::Vector3 *arg2 = 0 ;
9969   Dali::Radian *arg3 = 0 ;
9970   bool result;
9971
9972   arg1 = (Dali::Quaternion *)jarg1;
9973   arg2 = (Dali::Vector3 *)jarg2;
9974   if (!arg2) {
9975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9976     return 0;
9977   }
9978   arg3 = (Dali::Radian *)jarg3;
9979   if (!arg3) {
9980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9981     return 0;
9982   }
9983   {
9984     try {
9985       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (...) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9997       };
9998     }
9999   }
10000   jresult = result;
10001   return jresult;
10002 }
10003
10004
10005 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_AsVector(void * jarg1) {
10006   void * jresult ;
10007   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10008   Dali::Vector4 *result = 0 ;
10009
10010   arg1 = (Dali::Quaternion *)jarg1;
10011   {
10012     try {
10013       result = (Dali::Vector4 *) &((Dali::Quaternion const *)arg1)->AsVector();
10014     } catch (std::out_of_range& e) {
10015       {
10016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10017       };
10018     } catch (std::exception& e) {
10019       {
10020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10021       };
10022     } catch (...) {
10023       {
10024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10025       };
10026     }
10027   }
10028   jresult = (void *)result;
10029   return jresult;
10030 }
10031
10032
10033 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_SetEuler(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
10034   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10035   Dali::Radian arg2 ;
10036   Dali::Radian arg3 ;
10037   Dali::Radian arg4 ;
10038   Dali::Radian *argp2 ;
10039   Dali::Radian *argp3 ;
10040   Dali::Radian *argp4 ;
10041
10042   arg1 = (Dali::Quaternion *)jarg1;
10043   argp2 = (Dali::Radian *)jarg2;
10044   if (!argp2) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10046     return ;
10047   }
10048   arg2 = *argp2;
10049   argp3 = (Dali::Radian *)jarg3;
10050   if (!argp3) {
10051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10052     return ;
10053   }
10054   arg3 = *argp3;
10055   argp4 = (Dali::Radian *)jarg4;
10056   if (!argp4) {
10057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10058     return ;
10059   }
10060   arg4 = *argp4;
10061   {
10062     try {
10063       (arg1)->SetEuler(arg2,arg3,arg4);
10064     } catch (std::out_of_range& e) {
10065       {
10066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10067       };
10068     } catch (std::exception& e) {
10069       {
10070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10075       };
10076     }
10077   }
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_EulerAngles(void * jarg1) {
10082   void * jresult ;
10083   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10084   Dali::Vector4 result;
10085
10086   arg1 = (Dali::Quaternion *)jarg1;
10087   {
10088     try {
10089       result = ((Dali::Quaternion const *)arg1)->EulerAngles();
10090     } catch (std::out_of_range& e) {
10091       {
10092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10093       };
10094     } catch (std::exception& e) {
10095       {
10096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10097       };
10098     } catch (...) {
10099       {
10100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10101       };
10102     }
10103   }
10104   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Add(void * jarg1, void * jarg2) {
10110   void * jresult ;
10111   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10112   Dali::Quaternion *arg2 = 0 ;
10113   Dali::Quaternion result;
10114
10115   arg1 = (Dali::Quaternion *)jarg1;
10116   arg2 = (Dali::Quaternion *)jarg2;
10117   if (!arg2) {
10118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10119     return 0;
10120   }
10121   {
10122     try {
10123       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10124     } catch (std::out_of_range& e) {
10125       {
10126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10127       };
10128     } catch (std::exception& e) {
10129       {
10130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10131       };
10132     } catch (...) {
10133       {
10134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10135       };
10136     }
10137   }
10138   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10139   return jresult;
10140 }
10141
10142
10143 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10144   void * jresult ;
10145   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10146   Dali::Quaternion *arg2 = 0 ;
10147   Dali::Quaternion result;
10148
10149   arg1 = (Dali::Quaternion *)jarg1;
10150   arg2 = (Dali::Quaternion *)jarg2;
10151   if (!arg2) {
10152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10153     return 0;
10154   }
10155   {
10156     try {
10157       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10158     } catch (std::out_of_range& e) {
10159       {
10160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10161       };
10162     } catch (std::exception& e) {
10163       {
10164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10165       };
10166     } catch (...) {
10167       {
10168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10169       };
10170     }
10171   }
10172   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10178   void * jresult ;
10179   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10180   Dali::Quaternion *arg2 = 0 ;
10181   Dali::Quaternion result;
10182
10183   arg1 = (Dali::Quaternion *)jarg1;
10184   arg2 = (Dali::Quaternion *)jarg2;
10185   if (!arg2) {
10186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10187     return 0;
10188   }
10189   {
10190     try {
10191       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10192     } catch (std::out_of_range& e) {
10193       {
10194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10195       };
10196     } catch (std::exception& e) {
10197       {
10198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (...) {
10201       {
10202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10203       };
10204     }
10205   }
10206   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10207   return jresult;
10208 }
10209
10210
10211 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10212   void * jresult ;
10213   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10214   Dali::Vector3 *arg2 = 0 ;
10215   Dali::Vector3 result;
10216
10217   arg1 = (Dali::Quaternion *)jarg1;
10218   arg2 = (Dali::Vector3 *)jarg2;
10219   if (!arg2) {
10220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10221     return 0;
10222   }
10223   {
10224     try {
10225       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10226     } catch (std::out_of_range& e) {
10227       {
10228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10229       };
10230     } catch (std::exception& e) {
10231       {
10232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (...) {
10235       {
10236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10237       };
10238     }
10239   }
10240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10241   return jresult;
10242 }
10243
10244
10245 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Divide__SWIG_0(void * jarg1, void * jarg2) {
10246   void * jresult ;
10247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10248   Dali::Quaternion *arg2 = 0 ;
10249   Dali::Quaternion result;
10250
10251   arg1 = (Dali::Quaternion *)jarg1;
10252   arg2 = (Dali::Quaternion *)jarg2;
10253   if (!arg2) {
10254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10255     return 0;
10256   }
10257   {
10258     try {
10259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10260     } catch (std::out_of_range& e) {
10261       {
10262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10263       };
10264     } catch (std::exception& e) {
10265       {
10266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10267       };
10268     } catch (...) {
10269       {
10270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10271       };
10272     }
10273   }
10274   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10275   return jresult;
10276 }
10277
10278
10279 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Multiply__SWIG_2(void * jarg1, float jarg2) {
10280   void * jresult ;
10281   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10282   float arg2 ;
10283   Dali::Quaternion result;
10284
10285   arg1 = (Dali::Quaternion *)jarg1;
10286   arg2 = (float)jarg2;
10287   {
10288     try {
10289       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10290     } catch (std::out_of_range& e) {
10291       {
10292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10293       };
10294     } catch (std::exception& e) {
10295       {
10296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10297       };
10298     } catch (...) {
10299       {
10300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10301       };
10302     }
10303   }
10304   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10305   return jresult;
10306 }
10307
10308
10309 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Divide__SWIG_1(void * jarg1, float jarg2) {
10310   void * jresult ;
10311   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10312   float arg2 ;
10313   Dali::Quaternion result;
10314
10315   arg1 = (Dali::Quaternion *)jarg1;
10316   arg2 = (float)jarg2;
10317   {
10318     try {
10319       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10320     } catch (std::out_of_range& e) {
10321       {
10322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10323       };
10324     } catch (std::exception& e) {
10325       {
10326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (...) {
10329       {
10330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10331       };
10332     }
10333   }
10334   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10335   return jresult;
10336 }
10337
10338
10339 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Subtract__SWIG_1(void * jarg1) {
10340   void * jresult ;
10341   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10342   Dali::Quaternion result;
10343
10344   arg1 = (Dali::Quaternion *)jarg1;
10345   {
10346     try {
10347       result = ((Dali::Quaternion const *)arg1)->operator -();
10348     } catch (std::out_of_range& e) {
10349       {
10350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10351       };
10352     } catch (std::exception& e) {
10353       {
10354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10355       };
10356     } catch (...) {
10357       {
10358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10359       };
10360     }
10361   }
10362   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10363   return jresult;
10364 }
10365
10366
10367 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_AddAssign(void * jarg1, void * jarg2) {
10368   void * jresult ;
10369   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10370   Dali::Quaternion *arg2 = 0 ;
10371   Dali::Quaternion *result = 0 ;
10372
10373   arg1 = (Dali::Quaternion *)jarg1;
10374   arg2 = (Dali::Quaternion *)jarg2;
10375   if (!arg2) {
10376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10377     return 0;
10378   }
10379   {
10380     try {
10381       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10382     } catch (std::out_of_range& e) {
10383       {
10384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10385       };
10386     } catch (std::exception& e) {
10387       {
10388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10389       };
10390     } catch (...) {
10391       {
10392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10393       };
10394     }
10395   }
10396   jresult = (void *)result;
10397   return jresult;
10398 }
10399
10400
10401 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_SubtractAssign(void * jarg1, void * jarg2) {
10402   void * jresult ;
10403   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10404   Dali::Quaternion *arg2 = 0 ;
10405   Dali::Quaternion *result = 0 ;
10406
10407   arg1 = (Dali::Quaternion *)jarg1;
10408   arg2 = (Dali::Quaternion *)jarg2;
10409   if (!arg2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10411     return 0;
10412   }
10413   {
10414     try {
10415       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10416     } catch (std::out_of_range& e) {
10417       {
10418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (std::exception& e) {
10421       {
10422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (...) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10427       };
10428     }
10429   }
10430   jresult = (void *)result;
10431   return jresult;
10432 }
10433
10434
10435 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10436   void * jresult ;
10437   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10438   Dali::Quaternion *arg2 = 0 ;
10439   Dali::Quaternion *result = 0 ;
10440
10441   arg1 = (Dali::Quaternion *)jarg1;
10442   arg2 = (Dali::Quaternion *)jarg2;
10443   if (!arg2) {
10444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10445     return 0;
10446   }
10447   {
10448     try {
10449       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10450     } catch (std::out_of_range& e) {
10451       {
10452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10453       };
10454     } catch (std::exception& e) {
10455       {
10456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (...) {
10459       {
10460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10461       };
10462     }
10463   }
10464   jresult = (void *)result;
10465   return jresult;
10466 }
10467
10468
10469 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10470   void * jresult ;
10471   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10472   float arg2 ;
10473   Dali::Quaternion *result = 0 ;
10474
10475   arg1 = (Dali::Quaternion *)jarg1;
10476   arg2 = (float)jarg2;
10477   {
10478     try {
10479       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10480     } catch (std::out_of_range& e) {
10481       {
10482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10483       };
10484     } catch (std::exception& e) {
10485       {
10486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10487       };
10488     } catch (...) {
10489       {
10490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10491       };
10492     }
10493   }
10494   jresult = (void *)result;
10495   return jresult;
10496 }
10497
10498
10499 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_DivideAssign(void * jarg1, float jarg2) {
10500   void * jresult ;
10501   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10502   float arg2 ;
10503   Dali::Quaternion *result = 0 ;
10504
10505   arg1 = (Dali::Quaternion *)jarg1;
10506   arg2 = (float)jarg2;
10507   {
10508     try {
10509       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524   jresult = (void *)result;
10525   return jresult;
10526 }
10527
10528
10529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_EqualTo(void * jarg1, void * jarg2) {
10530   unsigned int jresult ;
10531   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10532   Dali::Quaternion *arg2 = 0 ;
10533   bool result;
10534
10535   arg1 = (Dali::Quaternion *)jarg1;
10536   arg2 = (Dali::Quaternion *)jarg2;
10537   if (!arg2) {
10538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10539     return 0;
10540   }
10541   {
10542     try {
10543       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10544     } catch (std::out_of_range& e) {
10545       {
10546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10547       };
10548     } catch (std::exception& e) {
10549       {
10550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10551       };
10552     } catch (...) {
10553       {
10554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10555       };
10556     }
10557   }
10558   jresult = result;
10559   return jresult;
10560 }
10561
10562
10563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Quaternion_NotEqualTo(void * jarg1, void * jarg2) {
10564   unsigned int jresult ;
10565   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10566   Dali::Quaternion *arg2 = 0 ;
10567   bool result;
10568
10569   arg1 = (Dali::Quaternion *)jarg1;
10570   arg2 = (Dali::Quaternion *)jarg2;
10571   if (!arg2) {
10572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10573     return 0;
10574   }
10575   {
10576     try {
10577       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10578     } catch (std::out_of_range& e) {
10579       {
10580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10581       };
10582     } catch (std::exception& e) {
10583       {
10584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10585       };
10586     } catch (...) {
10587       {
10588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10589       };
10590     }
10591   }
10592   jresult = result;
10593   return jresult;
10594 }
10595
10596
10597 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_Length(void * jarg1) {
10598   float jresult ;
10599   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10600   float result;
10601
10602   arg1 = (Dali::Quaternion *)jarg1;
10603   {
10604     try {
10605       result = (float)((Dali::Quaternion const *)arg1)->Length();
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (...) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10617       };
10618     }
10619   }
10620   jresult = result;
10621   return jresult;
10622 }
10623
10624
10625 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_LengthSquared(void * jarg1) {
10626   float jresult ;
10627   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10628   float result;
10629
10630   arg1 = (Dali::Quaternion *)jarg1;
10631   {
10632     try {
10633       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10634     } catch (std::out_of_range& e) {
10635       {
10636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10637       };
10638     } catch (std::exception& e) {
10639       {
10640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (...) {
10643       {
10644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10645       };
10646     }
10647   }
10648   jresult = result;
10649   return jresult;
10650 }
10651
10652
10653 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Normalize(void * jarg1) {
10654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10655
10656   arg1 = (Dali::Quaternion *)jarg1;
10657   {
10658     try {
10659       (arg1)->Normalize();
10660     } catch (std::out_of_range& e) {
10661       {
10662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10663       };
10664     } catch (std::exception& e) {
10665       {
10666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10667       };
10668     } catch (...) {
10669       {
10670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10671       };
10672     }
10673   }
10674 }
10675
10676
10677 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Normalized(void * jarg1) {
10678   void * jresult ;
10679   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10680   Dali::Quaternion result;
10681
10682   arg1 = (Dali::Quaternion *)jarg1;
10683   {
10684     try {
10685       result = ((Dali::Quaternion const *)arg1)->Normalized();
10686     } catch (std::out_of_range& e) {
10687       {
10688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10689       };
10690     } catch (std::exception& e) {
10691       {
10692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10693       };
10694     } catch (...) {
10695       {
10696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10697       };
10698     }
10699   }
10700   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10701   return jresult;
10702 }
10703
10704
10705 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Conjugate(void * jarg1) {
10706   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10707
10708   arg1 = (Dali::Quaternion *)jarg1;
10709   {
10710     try {
10711       (arg1)->Conjugate();
10712     } catch (std::out_of_range& e) {
10713       {
10714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10715       };
10716     } catch (std::exception& e) {
10717       {
10718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10719       };
10720     } catch (...) {
10721       {
10722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10723       };
10724     }
10725   }
10726 }
10727
10728
10729 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_Invert(void * jarg1) {
10730   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10731
10732   arg1 = (Dali::Quaternion *)jarg1;
10733   {
10734     try {
10735       (arg1)->Invert();
10736     } catch (std::out_of_range& e) {
10737       {
10738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10739       };
10740     } catch (std::exception& e) {
10741       {
10742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10743       };
10744     } catch (...) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10747       };
10748     }
10749   }
10750 }
10751
10752
10753 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Log(void * jarg1) {
10754   void * jresult ;
10755   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10756   Dali::Quaternion result;
10757
10758   arg1 = (Dali::Quaternion *)jarg1;
10759   {
10760     try {
10761       result = ((Dali::Quaternion const *)arg1)->Log();
10762     } catch (std::out_of_range& e) {
10763       {
10764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10765       };
10766     } catch (std::exception& e) {
10767       {
10768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10769       };
10770     } catch (...) {
10771       {
10772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10773       };
10774     }
10775   }
10776   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10777   return jresult;
10778 }
10779
10780
10781 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Exp(void * jarg1) {
10782   void * jresult ;
10783   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10784   Dali::Quaternion result;
10785
10786   arg1 = (Dali::Quaternion *)jarg1;
10787   {
10788     try {
10789       result = ((Dali::Quaternion const *)arg1)->Exp();
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (...) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10801       };
10802     }
10803   }
10804   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10805   return jresult;
10806 }
10807
10808
10809 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_Dot(void * jarg1, void * jarg2) {
10810   float jresult ;
10811   Dali::Quaternion *arg1 = 0 ;
10812   Dali::Quaternion *arg2 = 0 ;
10813   float result;
10814
10815   arg1 = (Dali::Quaternion *)jarg1;
10816   if (!arg1) {
10817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10818     return 0;
10819   }
10820   arg2 = (Dali::Quaternion *)jarg2;
10821   if (!arg2) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10823     return 0;
10824   }
10825   {
10826     try {
10827       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10828     } catch (std::out_of_range& e) {
10829       {
10830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (std::exception& e) {
10833       {
10834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842   jresult = result;
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Lerp(void * jarg1, void * jarg2, float jarg3) {
10848   void * jresult ;
10849   Dali::Quaternion *arg1 = 0 ;
10850   Dali::Quaternion *arg2 = 0 ;
10851   float arg3 ;
10852   Dali::Quaternion result;
10853
10854   arg1 = (Dali::Quaternion *)jarg1;
10855   if (!arg1) {
10856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10857     return 0;
10858   }
10859   arg2 = (Dali::Quaternion *)jarg2;
10860   if (!arg2) {
10861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10862     return 0;
10863   }
10864   arg3 = (float)jarg3;
10865   {
10866     try {
10867       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10868     } catch (std::out_of_range& e) {
10869       {
10870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (std::exception& e) {
10873       {
10874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (...) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10879       };
10880     }
10881   }
10882   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10883   return jresult;
10884 }
10885
10886
10887 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Slerp(void * jarg1, void * jarg2, float jarg3) {
10888   void * jresult ;
10889   Dali::Quaternion *arg1 = 0 ;
10890   Dali::Quaternion *arg2 = 0 ;
10891   float arg3 ;
10892   Dali::Quaternion result;
10893
10894   arg1 = (Dali::Quaternion *)jarg1;
10895   if (!arg1) {
10896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10897     return 0;
10898   }
10899   arg2 = (Dali::Quaternion *)jarg2;
10900   if (!arg2) {
10901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10902     return 0;
10903   }
10904   arg3 = (float)jarg3;
10905   {
10906     try {
10907       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10908     } catch (std::out_of_range& e) {
10909       {
10910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10911       };
10912     } catch (std::exception& e) {
10913       {
10914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (...) {
10917       {
10918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10919       };
10920     }
10921   }
10922   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10928   void * jresult ;
10929   Dali::Quaternion *arg1 = 0 ;
10930   Dali::Quaternion *arg2 = 0 ;
10931   float arg3 ;
10932   Dali::Quaternion result;
10933
10934   arg1 = (Dali::Quaternion *)jarg1;
10935   if (!arg1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10937     return 0;
10938   }
10939   arg2 = (Dali::Quaternion *)jarg2;
10940   if (!arg2) {
10941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10942     return 0;
10943   }
10944   arg3 = (float)jarg3;
10945   {
10946     try {
10947       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (...) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10959       };
10960     }
10961   }
10962   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10963   return jresult;
10964 }
10965
10966
10967 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10968   void * jresult ;
10969   Dali::Quaternion *arg1 = 0 ;
10970   Dali::Quaternion *arg2 = 0 ;
10971   Dali::Quaternion *arg3 = 0 ;
10972   Dali::Quaternion *arg4 = 0 ;
10973   float arg5 ;
10974   Dali::Quaternion result;
10975
10976   arg1 = (Dali::Quaternion *)jarg1;
10977   if (!arg1) {
10978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10979     return 0;
10980   }
10981   arg2 = (Dali::Quaternion *)jarg2;
10982   if (!arg2) {
10983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10984     return 0;
10985   }
10986   arg3 = (Dali::Quaternion *)jarg3;
10987   if (!arg3) {
10988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10989     return 0;
10990   }
10991   arg4 = (Dali::Quaternion *)jarg4;
10992   if (!arg4) {
10993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10994     return 0;
10995   }
10996   arg5 = (float)jarg5;
10997   {
10998     try {
10999       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11000     } catch (std::out_of_range& e) {
11001       {
11002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11003       };
11004     } catch (std::exception& e) {
11005       {
11006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11007       };
11008     } catch (...) {
11009       {
11010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11011       };
11012     }
11013   }
11014   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11015   return jresult;
11016 }
11017
11018
11019 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Quaternion_AngleBetween(void * jarg1, void * jarg2) {
11020   float jresult ;
11021   Dali::Quaternion *arg1 = 0 ;
11022   Dali::Quaternion *arg2 = 0 ;
11023   float result;
11024
11025   arg1 = (Dali::Quaternion *)jarg1;
11026   if (!arg1) {
11027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11028     return 0;
11029   }
11030   arg2 = (Dali::Quaternion *)jarg2;
11031   if (!arg2) {
11032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11033     return 0;
11034   }
11035   {
11036     try {
11037       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11038     } catch (std::out_of_range& e) {
11039       {
11040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11041       };
11042     } catch (std::exception& e) {
11043       {
11044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11045       };
11046     } catch (...) {
11047       {
11048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11049       };
11050     }
11051   }
11052   jresult = result;
11053   return jresult;
11054 }
11055
11056
11057 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Rotate__SWIG_0(void * jarg1, void * jarg2) {
11058   void * jresult ;
11059   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11060   Dali::Vector4 *arg2 = 0 ;
11061   Dali::Vector4 result;
11062
11063   arg1 = (Dali::Quaternion *)jarg1;
11064   arg2 = (Dali::Vector4 *)jarg2;
11065   if (!arg2) {
11066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11067     return 0;
11068   }
11069   {
11070     try {
11071       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector4 const &)*arg2);
11072     } catch (std::out_of_range& e) {
11073       {
11074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11075       };
11076     } catch (std::exception& e) {
11077       {
11078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11079       };
11080     } catch (...) {
11081       {
11082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11083       };
11084     }
11085   }
11086   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11087   return jresult;
11088 }
11089
11090
11091 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_Rotate__SWIG_1(void * jarg1, void * jarg2) {
11092   void * jresult ;
11093   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11094   Dali::Vector3 *arg2 = 0 ;
11095   Dali::Vector3 result;
11096
11097   arg1 = (Dali::Quaternion *)jarg1;
11098   arg2 = (Dali::Vector3 *)jarg2;
11099   if (!arg2) {
11100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11101     return 0;
11102   }
11103   {
11104     try {
11105       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector3 const &)*arg2);
11106     } catch (std::out_of_range& e) {
11107       {
11108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (std::exception& e) {
11111       {
11112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Quaternion_mVector_set(void * jarg1, void * jarg2) {
11126   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11127   Dali::Vector4 *arg2 = (Dali::Vector4 *) 0 ;
11128
11129   arg1 = (Dali::Quaternion *)jarg1;
11130   arg2 = (Dali::Vector4 *)jarg2;
11131   if (arg1) (arg1)->mVector = *arg2;
11132 }
11133
11134
11135 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Quaternion_mVector_get(void * jarg1) {
11136   void * jresult ;
11137   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11138   Dali::Vector4 *result = 0 ;
11139
11140   arg1 = (Dali::Quaternion *)jarg1;
11141   result = (Dali::Vector4 *)& ((arg1)->mVector);
11142   jresult = (void *)result;
11143   return jresult;
11144 }
11145
11146
11147 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_0() {
11148   void * jresult ;
11149   Dali::Matrix *result = 0 ;
11150
11151   {
11152     try {
11153       result = (Dali::Matrix *)new Dali::Matrix();
11154     } catch (std::out_of_range& e) {
11155       {
11156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11157       };
11158     } catch (std::exception& e) {
11159       {
11160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11161       };
11162     } catch (...) {
11163       {
11164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11165       };
11166     }
11167   }
11168   jresult = (void *)result;
11169   return jresult;
11170 }
11171
11172
11173 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_1(unsigned int jarg1) {
11174   void * jresult ;
11175   bool arg1 ;
11176   Dali::Matrix *result = 0 ;
11177
11178   arg1 = jarg1 ? true : false;
11179   {
11180     try {
11181       result = (Dali::Matrix *)new Dali::Matrix(arg1);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (...) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11193       };
11194     }
11195   }
11196   jresult = (void *)result;
11197   return jresult;
11198 }
11199
11200
11201 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_2(float* jarg1) {
11202   void * jresult ;
11203   float *arg1 = (float *) 0 ;
11204   Dali::Matrix *result = 0 ;
11205
11206   arg1 = jarg1;
11207   {
11208     try {
11209       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
11210     } catch (std::out_of_range& e) {
11211       {
11212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11213       };
11214     } catch (std::exception& e) {
11215       {
11216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11217       };
11218     } catch (...) {
11219       {
11220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11221       };
11222     }
11223   }
11224   jresult = (void *)result;
11225
11226
11227   return jresult;
11228 }
11229
11230
11231 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_3(void * jarg1) {
11232   void * jresult ;
11233   Dali::Quaternion *arg1 = 0 ;
11234   Dali::Matrix *result = 0 ;
11235
11236   arg1 = (Dali::Quaternion *)jarg1;
11237   if (!arg1) {
11238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11239     return 0;
11240   }
11241   {
11242     try {
11243       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11244     } catch (std::out_of_range& e) {
11245       {
11246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11247       };
11248     } catch (std::exception& e) {
11249       {
11250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (...) {
11253       {
11254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11255       };
11256     }
11257   }
11258   jresult = (void *)result;
11259   return jresult;
11260 }
11261
11262
11263 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix__SWIG_4(void * jarg1) {
11264   void * jresult ;
11265   Dali::Matrix *arg1 = 0 ;
11266   Dali::Matrix *result = 0 ;
11267
11268   arg1 = (Dali::Matrix *)jarg1;
11269   if (!arg1) {
11270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11271     return 0;
11272   }
11273   {
11274     try {
11275       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11276     } catch (std::out_of_range& e) {
11277       {
11278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11279       };
11280     } catch (std::exception& e) {
11281       {
11282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11283       };
11284     } catch (...) {
11285       {
11286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11287       };
11288     }
11289   }
11290   jresult = (void *)result;
11291   return jresult;
11292 }
11293
11294
11295 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_Assign(void * jarg1, void * jarg2) {
11296   void * jresult ;
11297   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11298   Dali::Matrix *arg2 = 0 ;
11299   Dali::Matrix *result = 0 ;
11300
11301   arg1 = (Dali::Matrix *)jarg1;
11302   arg2 = (Dali::Matrix *)jarg2;
11303   if (!arg2) {
11304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11305     return 0;
11306   }
11307   {
11308     try {
11309       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11310     } catch (std::out_of_range& e) {
11311       {
11312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11313       };
11314     } catch (std::exception& e) {
11315       {
11316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11317       };
11318     } catch (...) {
11319       {
11320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11321       };
11322     }
11323   }
11324   jresult = (void *)result;
11325   return jresult;
11326 }
11327
11328
11329 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_IDENTITY_get() {
11330   void * jresult ;
11331   Dali::Matrix *result = 0 ;
11332
11333   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11334   jresult = (void *)result;
11335   return jresult;
11336 }
11337
11338
11339 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetIdentity(void * jarg1) {
11340   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11341
11342   arg1 = (Dali::Matrix *)jarg1;
11343   {
11344     try {
11345       (arg1)->SetIdentity();
11346     } catch (std::out_of_range& e) {
11347       {
11348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11349       };
11350     } catch (std::exception& e) {
11351       {
11352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11353       };
11354     } catch (...) {
11355       {
11356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11357       };
11358     }
11359   }
11360 }
11361
11362
11363 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11365   Dali::Vector3 *arg2 = 0 ;
11366
11367   arg1 = (Dali::Matrix *)jarg1;
11368   arg2 = (Dali::Vector3 *)jarg2;
11369   if (!arg2) {
11370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11371     return ;
11372   }
11373   {
11374     try {
11375       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11376     } catch (std::out_of_range& e) {
11377       {
11378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11379       };
11380     } catch (std::exception& e) {
11381       {
11382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11383       };
11384     } catch (...) {
11385       {
11386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11387       };
11388     }
11389   }
11390 }
11391
11392
11393 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11394   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11395   Dali::Matrix *arg2 = 0 ;
11396
11397   arg1 = (Dali::Matrix *)jarg1;
11398   arg2 = (Dali::Matrix *)jarg2;
11399   if (!arg2) {
11400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11401     return ;
11402   }
11403   {
11404     try {
11405       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11406     } catch (std::out_of_range& e) {
11407       {
11408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11409       };
11410     } catch (std::exception& e) {
11411       {
11412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11417       };
11418     }
11419   }
11420 }
11421
11422
11423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_Invert(void * jarg1) {
11424   unsigned int jresult ;
11425   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11426   bool result;
11427
11428   arg1 = (Dali::Matrix *)jarg1;
11429   {
11430     try {
11431       result = (bool)(arg1)->Invert();
11432     } catch (std::out_of_range& e) {
11433       {
11434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11435       };
11436     } catch (std::exception& e) {
11437       {
11438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11439       };
11440     } catch (...) {
11441       {
11442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11443       };
11444     }
11445   }
11446   jresult = result;
11447   return jresult;
11448 }
11449
11450
11451 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Transpose(void * jarg1) {
11452   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11453
11454   arg1 = (Dali::Matrix *)jarg1;
11455   {
11456     try {
11457       (arg1)->Transpose();
11458     } catch (std::out_of_range& e) {
11459       {
11460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11461       };
11462     } catch (std::exception& e) {
11463       {
11464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11465       };
11466     } catch (...) {
11467       {
11468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11469       };
11470     }
11471   }
11472 }
11473
11474
11475 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetXAxis(void * jarg1) {
11476   void * jresult ;
11477   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11478   Dali::Vector3 result;
11479
11480   arg1 = (Dali::Matrix *)jarg1;
11481   {
11482     try {
11483       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11484     } catch (std::out_of_range& e) {
11485       {
11486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (std::exception& e) {
11489       {
11490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11499   return jresult;
11500 }
11501
11502
11503 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetYAxis(void * jarg1) {
11504   void * jresult ;
11505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11506   Dali::Vector3 result;
11507
11508   arg1 = (Dali::Matrix *)jarg1;
11509   {
11510     try {
11511       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11512     } catch (std::out_of_range& e) {
11513       {
11514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11515       };
11516     } catch (std::exception& e) {
11517       {
11518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (...) {
11521       {
11522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11523       };
11524     }
11525   }
11526   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11527   return jresult;
11528 }
11529
11530
11531 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetZAxis(void * jarg1) {
11532   void * jresult ;
11533   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11534   Dali::Vector3 result;
11535
11536   arg1 = (Dali::Matrix *)jarg1;
11537   {
11538     try {
11539       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11540     } catch (std::out_of_range& e) {
11541       {
11542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11543       };
11544     } catch (std::exception& e) {
11545       {
11546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11547       };
11548     } catch (...) {
11549       {
11550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11551       };
11552     }
11553   }
11554   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11555   return jresult;
11556 }
11557
11558
11559 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11560   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11561   Dali::Vector3 *arg2 = 0 ;
11562
11563   arg1 = (Dali::Matrix *)jarg1;
11564   arg2 = (Dali::Vector3 *)jarg2;
11565   if (!arg2) {
11566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11567     return ;
11568   }
11569   {
11570     try {
11571       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11572     } catch (std::out_of_range& e) {
11573       {
11574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11575       };
11576     } catch (std::exception& e) {
11577       {
11578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11579       };
11580     } catch (...) {
11581       {
11582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11583       };
11584     }
11585   }
11586 }
11587
11588
11589 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11590   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11591   Dali::Vector3 *arg2 = 0 ;
11592
11593   arg1 = (Dali::Matrix *)jarg1;
11594   arg2 = (Dali::Vector3 *)jarg2;
11595   if (!arg2) {
11596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11597     return ;
11598   }
11599   {
11600     try {
11601       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11602     } catch (std::out_of_range& e) {
11603       {
11604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11605       };
11606     } catch (std::exception& e) {
11607       {
11608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11609       };
11610     } catch (...) {
11611       {
11612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11613       };
11614     }
11615   }
11616 }
11617
11618
11619 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11621   Dali::Vector3 *arg2 = 0 ;
11622
11623   arg1 = (Dali::Matrix *)jarg1;
11624   arg2 = (Dali::Vector3 *)jarg2;
11625   if (!arg2) {
11626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11627     return ;
11628   }
11629   {
11630     try {
11631       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11632     } catch (std::out_of_range& e) {
11633       {
11634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11635       };
11636     } catch (std::exception& e) {
11637       {
11638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11643       };
11644     }
11645   }
11646 }
11647
11648
11649 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetTranslation(void * jarg1) {
11650   void * jresult ;
11651   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11652   Dali::Vector4 *result = 0 ;
11653
11654   arg1 = (Dali::Matrix *)jarg1;
11655   {
11656     try {
11657       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11658     } catch (std::out_of_range& e) {
11659       {
11660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (std::exception& e) {
11663       {
11664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11665       };
11666     } catch (...) {
11667       {
11668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11669       };
11670     }
11671   }
11672   jresult = (void *)result;
11673   return jresult;
11674 }
11675
11676
11677 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_GetTranslation3(void * jarg1) {
11678   void * jresult ;
11679   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11680   Dali::Vector3 *result = 0 ;
11681
11682   arg1 = (Dali::Matrix *)jarg1;
11683   {
11684     try {
11685       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11686     } catch (std::out_of_range& e) {
11687       {
11688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11689       };
11690     } catch (std::exception& e) {
11691       {
11692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11693       };
11694     } catch (...) {
11695       {
11696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11697       };
11698     }
11699   }
11700   jresult = (void *)result;
11701   return jresult;
11702 }
11703
11704
11705 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11706   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11707   Dali::Vector4 *arg2 = 0 ;
11708
11709   arg1 = (Dali::Matrix *)jarg1;
11710   arg2 = (Dali::Vector4 *)jarg2;
11711   if (!arg2) {
11712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11713     return ;
11714   }
11715   {
11716     try {
11717       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11718     } catch (std::out_of_range& e) {
11719       {
11720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11721       };
11722     } catch (std::exception& e) {
11723       {
11724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (...) {
11727       {
11728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11729       };
11730     }
11731   }
11732 }
11733
11734
11735 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11736   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11737   Dali::Vector3 *arg2 = 0 ;
11738
11739   arg1 = (Dali::Matrix *)jarg1;
11740   arg2 = (Dali::Vector3 *)jarg2;
11741   if (!arg2) {
11742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11743     return ;
11744   }
11745   {
11746     try {
11747       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11748     } catch (std::out_of_range& e) {
11749       {
11750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11751       };
11752     } catch (std::exception& e) {
11753       {
11754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11755       };
11756     } catch (...) {
11757       {
11758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11759       };
11760     }
11761   }
11762 }
11763
11764
11765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_OrthoNormalize(void * jarg1) {
11766   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11767
11768   arg1 = (Dali::Matrix *)jarg1;
11769   {
11770     try {
11771       (arg1)->OrthoNormalize();
11772     } catch (std::out_of_range& e) {
11773       {
11774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11775       };
11776     } catch (std::exception& e) {
11777       {
11778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11779       };
11780     } catch (...) {
11781       {
11782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11783       };
11784     }
11785   }
11786 }
11787
11788
11789 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_AsFloat__SWIG_0(void * jarg1) {
11790   void * jresult ;
11791   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11792   float *result = 0 ;
11793
11794   arg1 = (Dali::Matrix *)jarg1;
11795   {
11796     try {
11797       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11798     } catch (std::out_of_range& e) {
11799       {
11800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11801       };
11802     } catch (std::exception& e) {
11803       {
11804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11805       };
11806     } catch (...) {
11807       {
11808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11809       };
11810     }
11811   }
11812   jresult = (void *)result;
11813   return jresult;
11814 }
11815
11816
11817 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11818   Dali::Matrix *arg1 = 0 ;
11819   Dali::Matrix *arg2 = 0 ;
11820   Dali::Matrix *arg3 = 0 ;
11821
11822   arg1 = (Dali::Matrix *)jarg1;
11823   if (!arg1) {
11824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11825     return ;
11826   }
11827   arg2 = (Dali::Matrix *)jarg2;
11828   if (!arg2) {
11829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11830     return ;
11831   }
11832   arg3 = (Dali::Matrix *)jarg3;
11833   if (!arg3) {
11834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11835     return ;
11836   }
11837   {
11838     try {
11839       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11840     } catch (std::out_of_range& e) {
11841       {
11842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11843       };
11844     } catch (std::exception& e) {
11845       {
11846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11847       };
11848     } catch (...) {
11849       {
11850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11851       };
11852     }
11853   }
11854 }
11855
11856
11857 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11858   Dali::Matrix *arg1 = 0 ;
11859   Dali::Matrix *arg2 = 0 ;
11860   Dali::Quaternion *arg3 = 0 ;
11861
11862   arg1 = (Dali::Matrix *)jarg1;
11863   if (!arg1) {
11864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11865     return ;
11866   }
11867   arg2 = (Dali::Matrix *)jarg2;
11868   if (!arg2) {
11869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11870     return ;
11871   }
11872   arg3 = (Dali::Quaternion *)jarg3;
11873   if (!arg3) {
11874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11875     return ;
11876   }
11877   {
11878     try {
11879       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11887       };
11888     } catch (...) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11891       };
11892     }
11893   }
11894 }
11895
11896
11897 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11898   void * jresult ;
11899   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11900   Dali::Vector4 *arg2 = 0 ;
11901   Dali::Vector4 result;
11902
11903   arg1 = (Dali::Matrix *)jarg1;
11904   arg2 = (Dali::Vector4 *)jarg2;
11905   if (!arg2) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11907     return 0;
11908   }
11909   {
11910     try {
11911       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11912     } catch (std::out_of_range& e) {
11913       {
11914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11915       };
11916     } catch (std::exception& e) {
11917       {
11918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11919       };
11920     } catch (...) {
11921       {
11922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11923       };
11924     }
11925   }
11926   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11927   return jresult;
11928 }
11929
11930
11931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_EqualTo(void * jarg1, void * jarg2) {
11932   unsigned int jresult ;
11933   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11934   Dali::Matrix *arg2 = 0 ;
11935   bool result;
11936
11937   arg1 = (Dali::Matrix *)jarg1;
11938   arg2 = (Dali::Matrix *)jarg2;
11939   if (!arg2) {
11940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11941     return 0;
11942   }
11943   {
11944     try {
11945       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11946     } catch (std::out_of_range& e) {
11947       {
11948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11949       };
11950     } catch (std::exception& e) {
11951       {
11952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11953       };
11954     } catch (...) {
11955       {
11956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11957       };
11958     }
11959   }
11960   jresult = result;
11961   return jresult;
11962 }
11963
11964
11965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11966   unsigned int jresult ;
11967   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11968   Dali::Matrix *arg2 = 0 ;
11969   bool result;
11970
11971   arg1 = (Dali::Matrix *)jarg1;
11972   arg2 = (Dali::Matrix *)jarg2;
11973   if (!arg2) {
11974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11975     return 0;
11976   }
11977   {
11978     try {
11979       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (...) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11991       };
11992     }
11993   }
11994   jresult = result;
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12000   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12001   Dali::Vector3 *arg2 = 0 ;
12002   Dali::Quaternion *arg3 = 0 ;
12003   Dali::Vector3 *arg4 = 0 ;
12004
12005   arg1 = (Dali::Matrix *)jarg1;
12006   arg2 = (Dali::Vector3 *)jarg2;
12007   if (!arg2) {
12008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12009     return ;
12010   }
12011   arg3 = (Dali::Quaternion *)jarg3;
12012   if (!arg3) {
12013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12014     return ;
12015   }
12016   arg4 = (Dali::Vector3 *)jarg4;
12017   if (!arg4) {
12018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12019     return ;
12020   }
12021   {
12022     try {
12023       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12024     } catch (std::out_of_range& e) {
12025       {
12026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12027       };
12028     } catch (std::exception& e) {
12029       {
12030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12031       };
12032     } catch (...) {
12033       {
12034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12035       };
12036     }
12037   }
12038 }
12039
12040
12041 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12042   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12043   Dali::Vector3 *arg2 = 0 ;
12044   Dali::Quaternion *arg3 = 0 ;
12045   Dali::Vector3 *arg4 = 0 ;
12046
12047   arg1 = (Dali::Matrix *)jarg1;
12048   arg2 = (Dali::Vector3 *)jarg2;
12049   if (!arg2) {
12050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12051     return ;
12052   }
12053   arg3 = (Dali::Quaternion *)jarg3;
12054   if (!arg3) {
12055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12056     return ;
12057   }
12058   arg4 = (Dali::Vector3 *)jarg4;
12059   if (!arg4) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12061     return ;
12062   }
12063   {
12064     try {
12065       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12066     } catch (std::out_of_range& e) {
12067       {
12068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12069       };
12070     } catch (std::exception& e) {
12071       {
12072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12073       };
12074     } catch (...) {
12075       {
12076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12077       };
12078     }
12079   }
12080 }
12081
12082
12083 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
12084   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12085   Dali::Vector3 *arg2 = 0 ;
12086   Dali::Vector3 *arg3 = 0 ;
12087   Dali::Vector3 *arg4 = 0 ;
12088   Dali::Vector3 *arg5 = 0 ;
12089
12090   arg1 = (Dali::Matrix *)jarg1;
12091   arg2 = (Dali::Vector3 *)jarg2;
12092   if (!arg2) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12094     return ;
12095   }
12096   arg3 = (Dali::Vector3 *)jarg3;
12097   if (!arg3) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12099     return ;
12100   }
12101   arg4 = (Dali::Vector3 *)jarg4;
12102   if (!arg4) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12104     return ;
12105   }
12106   arg5 = (Dali::Vector3 *)jarg5;
12107   if (!arg5) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12109     return ;
12110   }
12111   {
12112     try {
12113       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12125       };
12126     }
12127   }
12128 }
12129
12130
12131 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12133   Dali::Vector3 *arg2 = 0 ;
12134   Dali::Quaternion *arg3 = 0 ;
12135   Dali::Vector3 *arg4 = 0 ;
12136
12137   arg1 = (Dali::Matrix *)jarg1;
12138   arg2 = (Dali::Vector3 *)jarg2;
12139   if (!arg2) {
12140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12141     return ;
12142   }
12143   arg3 = (Dali::Quaternion *)jarg3;
12144   if (!arg3) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
12146     return ;
12147   }
12148   arg4 = (Dali::Vector3 *)jarg4;
12149   if (!arg4) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12151     return ;
12152   }
12153   {
12154     try {
12155       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12163       };
12164     } catch (...) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12167       };
12168     }
12169   }
12170 }
12171
12172
12173 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Matrix(void * jarg1) {
12174   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12175
12176   arg1 = (Dali::Matrix *)jarg1;
12177   {
12178     try {
12179       delete arg1;
12180     } catch (std::out_of_range& e) {
12181       {
12182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12183       };
12184     } catch (std::exception& e) {
12185       {
12186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12187       };
12188     } catch (...) {
12189       {
12190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12191       };
12192     }
12193   }
12194 }
12195
12196
12197 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_IDENTITY_get() {
12198   void * jresult ;
12199   Dali::Matrix3 *result = 0 ;
12200
12201   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
12202   jresult = (void *)result;
12203   return jresult;
12204 }
12205
12206
12207 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_0() {
12208   void * jresult ;
12209   Dali::Matrix3 *result = 0 ;
12210
12211   {
12212     try {
12213       result = (Dali::Matrix3 *)new Dali::Matrix3();
12214     } catch (std::out_of_range& e) {
12215       {
12216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12217       };
12218     } catch (std::exception& e) {
12219       {
12220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (...) {
12223       {
12224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12225       };
12226     }
12227   }
12228   jresult = (void *)result;
12229   return jresult;
12230 }
12231
12232
12233 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_1(void * jarg1) {
12234   void * jresult ;
12235   Dali::Matrix3 *arg1 = 0 ;
12236   Dali::Matrix3 *result = 0 ;
12237
12238   arg1 = (Dali::Matrix3 *)jarg1;
12239   if (!arg1) {
12240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12241     return 0;
12242   }
12243   {
12244     try {
12245       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12246     } catch (std::out_of_range& e) {
12247       {
12248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12249       };
12250     } catch (std::exception& e) {
12251       {
12252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12257       };
12258     }
12259   }
12260   jresult = (void *)result;
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Matrix3__SWIG_2(void * jarg1) {
12266   void * jresult ;
12267   Dali::Matrix *arg1 = 0 ;
12268   Dali::Matrix3 *result = 0 ;
12269
12270   arg1 = (Dali::Matrix *)jarg1;
12271   if (!arg1) {
12272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12273     return 0;
12274   }
12275   {
12276     try {
12277       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12278     } catch (std::out_of_range& e) {
12279       {
12280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12281       };
12282     } catch (std::exception& e) {
12283       {
12284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (...) {
12287       {
12288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12289       };
12290     }
12291   }
12292   jresult = (void *)result;
12293   return jresult;
12294 }
12295
12296
12297 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) {
12298   void * jresult ;
12299   float arg1 ;
12300   float arg2 ;
12301   float arg3 ;
12302   float arg4 ;
12303   float arg5 ;
12304   float arg6 ;
12305   float arg7 ;
12306   float arg8 ;
12307   float arg9 ;
12308   Dali::Matrix3 *result = 0 ;
12309
12310   arg1 = (float)jarg1;
12311   arg2 = (float)jarg2;
12312   arg3 = (float)jarg3;
12313   arg4 = (float)jarg4;
12314   arg5 = (float)jarg5;
12315   arg6 = (float)jarg6;
12316   arg7 = (float)jarg7;
12317   arg8 = (float)jarg8;
12318   arg9 = (float)jarg9;
12319   {
12320     try {
12321       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12322     } catch (std::out_of_range& e) {
12323       {
12324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12325       };
12326     } catch (std::exception& e) {
12327       {
12328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12329       };
12330     } catch (...) {
12331       {
12332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12333       };
12334     }
12335   }
12336   jresult = (void *)result;
12337   return jresult;
12338 }
12339
12340
12341 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12342   void * jresult ;
12343   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12344   Dali::Matrix3 *arg2 = 0 ;
12345   Dali::Matrix3 *result = 0 ;
12346
12347   arg1 = (Dali::Matrix3 *)jarg1;
12348   arg2 = (Dali::Matrix3 *)jarg2;
12349   if (!arg2) {
12350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12351     return 0;
12352   }
12353   {
12354     try {
12355       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12356     } catch (std::out_of_range& e) {
12357       {
12358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12359       };
12360     } catch (std::exception& e) {
12361       {
12362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12363       };
12364     } catch (...) {
12365       {
12366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12367       };
12368     }
12369   }
12370   jresult = (void *)result;
12371   return jresult;
12372 }
12373
12374
12375 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12376   void * jresult ;
12377   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12378   Dali::Matrix *arg2 = 0 ;
12379   Dali::Matrix3 *result = 0 ;
12380
12381   arg1 = (Dali::Matrix3 *)jarg1;
12382   arg2 = (Dali::Matrix *)jarg2;
12383   if (!arg2) {
12384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12385     return 0;
12386   }
12387   {
12388     try {
12389       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12390     } catch (std::out_of_range& e) {
12391       {
12392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12393       };
12394     } catch (std::exception& e) {
12395       {
12396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12397       };
12398     } catch (...) {
12399       {
12400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12401       };
12402     }
12403   }
12404   jresult = (void *)result;
12405   return jresult;
12406 }
12407
12408
12409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12410   unsigned int jresult ;
12411   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12412   Dali::Matrix3 *arg2 = 0 ;
12413   bool result;
12414
12415   arg1 = (Dali::Matrix3 *)jarg1;
12416   arg2 = (Dali::Matrix3 *)jarg2;
12417   if (!arg2) {
12418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12419     return 0;
12420   }
12421   {
12422     try {
12423       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12424     } catch (std::out_of_range& e) {
12425       {
12426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12427       };
12428     } catch (std::exception& e) {
12429       {
12430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12431       };
12432     } catch (...) {
12433       {
12434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12435       };
12436     }
12437   }
12438   jresult = result;
12439   return jresult;
12440 }
12441
12442
12443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12444   unsigned int jresult ;
12445   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12446   Dali::Matrix3 *arg2 = 0 ;
12447   bool result;
12448
12449   arg1 = (Dali::Matrix3 *)jarg1;
12450   arg2 = (Dali::Matrix3 *)jarg2;
12451   if (!arg2) {
12452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12453     return 0;
12454   }
12455   {
12456     try {
12457       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12458     } catch (std::out_of_range& e) {
12459       {
12460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12461       };
12462     } catch (std::exception& e) {
12463       {
12464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12465       };
12466     } catch (...) {
12467       {
12468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12469       };
12470     }
12471   }
12472   jresult = result;
12473   return jresult;
12474 }
12475
12476
12477 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Matrix3(void * jarg1) {
12478   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12479
12480   arg1 = (Dali::Matrix3 *)jarg1;
12481   {
12482     try {
12483       delete arg1;
12484     } catch (std::out_of_range& e) {
12485       {
12486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12487       };
12488     } catch (std::exception& e) {
12489       {
12490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12491       };
12492     } catch (...) {
12493       {
12494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12495       };
12496     }
12497   }
12498 }
12499
12500
12501 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_SetIdentity(void * jarg1) {
12502   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12503
12504   arg1 = (Dali::Matrix3 *)jarg1;
12505   {
12506     try {
12507       (arg1)->SetIdentity();
12508     } catch (std::out_of_range& e) {
12509       {
12510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12511       };
12512     } catch (std::exception& e) {
12513       {
12514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12515       };
12516     } catch (...) {
12517       {
12518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12519       };
12520     }
12521   }
12522 }
12523
12524
12525 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12526   void * jresult ;
12527   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12528   float *result = 0 ;
12529
12530   arg1 = (Dali::Matrix3 *)jarg1;
12531   {
12532     try {
12533       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12534     } catch (std::out_of_range& e) {
12535       {
12536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12537       };
12538     } catch (std::exception& e) {
12539       {
12540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12541       };
12542     } catch (...) {
12543       {
12544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12545       };
12546     }
12547   }
12548   jresult = (void *)result;
12549   return jresult;
12550 }
12551
12552
12553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_Invert(void * jarg1) {
12554   unsigned int jresult ;
12555   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12556   bool result;
12557
12558   arg1 = (Dali::Matrix3 *)jarg1;
12559   {
12560     try {
12561       result = (bool)(arg1)->Invert();
12562     } catch (std::out_of_range& e) {
12563       {
12564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12565       };
12566     } catch (std::exception& e) {
12567       {
12568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12573       };
12574     }
12575   }
12576   jresult = result;
12577   return jresult;
12578 }
12579
12580
12581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_Transpose(void * jarg1) {
12582   unsigned int jresult ;
12583   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12584   bool result;
12585
12586   arg1 = (Dali::Matrix3 *)jarg1;
12587   {
12588     try {
12589       result = (bool)(arg1)->Transpose();
12590     } catch (std::out_of_range& e) {
12591       {
12592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12593       };
12594     } catch (std::exception& e) {
12595       {
12596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12597       };
12598     } catch (...) {
12599       {
12600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12601       };
12602     }
12603   }
12604   jresult = result;
12605   return jresult;
12606 }
12607
12608
12609 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_Scale(void * jarg1, float jarg2) {
12610   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12611   float arg2 ;
12612
12613   arg1 = (Dali::Matrix3 *)jarg1;
12614   arg2 = (float)jarg2;
12615   {
12616     try {
12617       (arg1)->Scale(arg2);
12618     } catch (std::out_of_range& e) {
12619       {
12620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12621       };
12622     } catch (std::exception& e) {
12623       {
12624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12625       };
12626     } catch (...) {
12627       {
12628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12629       };
12630     }
12631   }
12632 }
12633
12634
12635 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Matrix3_Magnitude(void * jarg1) {
12636   float jresult ;
12637   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12638   float result;
12639
12640   arg1 = (Dali::Matrix3 *)jarg1;
12641   {
12642     try {
12643       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12644     } catch (std::out_of_range& e) {
12645       {
12646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (std::exception& e) {
12649       {
12650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658   jresult = result;
12659   return jresult;
12660 }
12661
12662
12663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Matrix3_ScaledInverseTranspose(void * jarg1) {
12664   unsigned int jresult ;
12665   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12666   bool result;
12667
12668   arg1 = (Dali::Matrix3 *)jarg1;
12669   {
12670     try {
12671       result = (bool)(arg1)->ScaledInverseTranspose();
12672     } catch (std::out_of_range& e) {
12673       {
12674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12675       };
12676     } catch (std::exception& e) {
12677       {
12678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12679       };
12680     } catch (...) {
12681       {
12682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12683       };
12684     }
12685   }
12686   jresult = result;
12687   return jresult;
12688 }
12689
12690
12691 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12692   Dali::Matrix3 *arg1 = 0 ;
12693   Dali::Matrix3 *arg2 = 0 ;
12694   Dali::Matrix3 *arg3 = 0 ;
12695
12696   arg1 = (Dali::Matrix3 *)jarg1;
12697   if (!arg1) {
12698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12699     return ;
12700   }
12701   arg2 = (Dali::Matrix3 *)jarg2;
12702   if (!arg2) {
12703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12704     return ;
12705   }
12706   arg3 = (Dali::Matrix3 *)jarg3;
12707   if (!arg3) {
12708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12709     return ;
12710   }
12711   {
12712     try {
12713       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12714     } catch (std::out_of_range& e) {
12715       {
12716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (std::exception& e) {
12719       {
12720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12721       };
12722     } catch (...) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12725       };
12726     }
12727   }
12728 }
12729
12730
12731 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Range(float jarg1, float jarg2) {
12732   float jresult ;
12733   float arg1 ;
12734   float arg2 ;
12735   float result;
12736
12737   arg1 = (float)jarg1;
12738   arg2 = (float)jarg2;
12739   {
12740     try {
12741       result = (float)Dali::Random::Range(arg1,arg2);
12742     } catch (std::out_of_range& e) {
12743       {
12744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12745       };
12746     } catch (std::exception& e) {
12747       {
12748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12749       };
12750     } catch (...) {
12751       {
12752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12753       };
12754     }
12755   }
12756   jresult = result;
12757   return jresult;
12758 }
12759
12760
12761 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Axis() {
12762   void * jresult ;
12763   Dali::Vector4 result;
12764
12765   {
12766     try {
12767       result = Dali::Random::Axis();
12768     } catch (std::out_of_range& e) {
12769       {
12770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12771       };
12772     } catch (std::exception& e) {
12773       {
12774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12775       };
12776     } catch (...) {
12777       {
12778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12779       };
12780     }
12781   }
12782   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12783   return jresult;
12784 }
12785
12786
12787 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleAxis__SWIG_0() {
12788   void * jresult ;
12789   Dali::AngleAxis *result = 0 ;
12790
12791   {
12792     try {
12793       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12794     } catch (std::out_of_range& e) {
12795       {
12796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12797       };
12798     } catch (std::exception& e) {
12799       {
12800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12801       };
12802     } catch (...) {
12803       {
12804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12805       };
12806     }
12807   }
12808   jresult = (void *)result;
12809   return jresult;
12810 }
12811
12812
12813 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12814   void * jresult ;
12815   Dali::Radian arg1 ;
12816   Dali::Vector3 *arg2 = 0 ;
12817   Dali::Radian *argp1 ;
12818   Dali::AngleAxis *result = 0 ;
12819
12820   argp1 = (Dali::Radian *)jarg1;
12821   if (!argp1) {
12822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12823     return 0;
12824   }
12825   arg1 = *argp1;
12826   arg2 = (Dali::Vector3 *)jarg2;
12827   if (!arg2) {
12828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12829     return 0;
12830   }
12831   {
12832     try {
12833       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12834     } catch (std::out_of_range& e) {
12835       {
12836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12837       };
12838     } catch (std::exception& e) {
12839       {
12840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12841       };
12842     } catch (...) {
12843       {
12844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12845       };
12846     }
12847   }
12848   jresult = (void *)result;
12849   return jresult;
12850 }
12851
12852
12853 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12854   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12855   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12856
12857   arg1 = (Dali::AngleAxis *)jarg1;
12858   arg2 = (Dali::Radian *)jarg2;
12859   if (arg1) (arg1)->angle = *arg2;
12860 }
12861
12862
12863 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleAxis_angle_get(void * jarg1) {
12864   void * jresult ;
12865   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12866   Dali::Radian *result = 0 ;
12867
12868   arg1 = (Dali::AngleAxis *)jarg1;
12869   result = (Dali::Radian *)& ((arg1)->angle);
12870   jresult = (void *)result;
12871   return jresult;
12872 }
12873
12874
12875 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12876   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12877   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12878
12879   arg1 = (Dali::AngleAxis *)jarg1;
12880   arg2 = (Dali::Vector3 *)jarg2;
12881   if (arg1) (arg1)->axis = *arg2;
12882 }
12883
12884
12885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleAxis_axis_get(void * jarg1) {
12886   void * jresult ;
12887   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12888   Dali::Vector3 *result = 0 ;
12889
12890   arg1 = (Dali::AngleAxis *)jarg1;
12891   result = (Dali::Vector3 *)& ((arg1)->axis);
12892   jresult = (void *)result;
12893   return jresult;
12894 }
12895
12896
12897 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AngleAxis(void * jarg1) {
12898   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12899
12900   arg1 = (Dali::AngleAxis *)jarg1;
12901   {
12902     try {
12903       delete arg1;
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12911       };
12912     } catch (...) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12915       };
12916     }
12917   }
12918 }
12919
12920
12921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12922   unsigned int jresult ;
12923   Dali::AngleAxis *arg1 = 0 ;
12924   Dali::AngleAxis *arg2 = 0 ;
12925   bool result;
12926
12927   arg1 = (Dali::AngleAxis *)jarg1;
12928   if (!arg1) {
12929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12930     return 0;
12931   }
12932   arg2 = (Dali::AngleAxis *)jarg2;
12933   if (!arg2) {
12934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12935     return 0;
12936   }
12937   {
12938     try {
12939       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12947       };
12948     } catch (...) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12951       };
12952     }
12953   }
12954   jresult = result;
12955   return jresult;
12956 }
12957
12958
12959 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_INDEX_get() {
12960   int jresult ;
12961   int result;
12962
12963   result = (int)(int)Dali::Property::INVALID_INDEX;
12964   jresult = result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_KEY_get() {
12970   int jresult ;
12971   int result;
12972
12973   result = (int)(int)Dali::Property::INVALID_KEY;
12974   jresult = result;
12975   return jresult;
12976 }
12977
12978
12979 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_INVALID_COMPONENT_INDEX_get() {
12980   int jresult ;
12981   int result;
12982
12983   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12984   jresult = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_0(void * jarg1, int jarg2) {
12990   void * jresult ;
12991   Dali::Handle *arg1 = 0 ;
12992   Dali::Property::Index arg2 ;
12993   Dali::Property *result = 0 ;
12994
12995   arg1 = (Dali::Handle *)jarg1;
12996   if (!arg1) {
12997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12998     return 0;
12999   }
13000   arg2 = (Dali::Property::Index)jarg2;
13001   {
13002     try {
13003       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13004     } catch (std::out_of_range& e) {
13005       {
13006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13007       };
13008     } catch (std::exception& e) {
13009       {
13010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13011       };
13012     } catch (...) {
13013       {
13014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13015       };
13016     }
13017   }
13018   jresult = (void *)result;
13019   return jresult;
13020 }
13021
13022
13023 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13024   void * jresult ;
13025   Dali::Handle *arg1 = 0 ;
13026   Dali::Property::Index arg2 ;
13027   int arg3 ;
13028   Dali::Property *result = 0 ;
13029
13030   arg1 = (Dali::Handle *)jarg1;
13031   if (!arg1) {
13032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13033     return 0;
13034   }
13035   arg2 = (Dali::Property::Index)jarg2;
13036   arg3 = (int)jarg3;
13037   {
13038     try {
13039       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13040     } catch (std::out_of_range& e) {
13041       {
13042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13043       };
13044     } catch (std::exception& e) {
13045       {
13046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13047       };
13048     } catch (...) {
13049       {
13050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13051       };
13052     }
13053   }
13054   jresult = (void *)result;
13055   return jresult;
13056 }
13057
13058
13059 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13060   void * jresult ;
13061   Dali::Handle *arg1 = 0 ;
13062   std::string *arg2 = 0 ;
13063   Dali::Property *result = 0 ;
13064
13065   arg1 = (Dali::Handle *)jarg1;
13066   if (!arg1) {
13067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13068     return 0;
13069   }
13070   if (!jarg2) {
13071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13072     return 0;
13073   }
13074   std::string arg2_str(jarg2);
13075   arg2 = &arg2_str;
13076   {
13077     try {
13078       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13079     } catch (std::out_of_range& e) {
13080       {
13081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13082       };
13083     } catch (std::exception& e) {
13084       {
13085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13086       };
13087     } catch (...) {
13088       {
13089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13090       };
13091     }
13092   }
13093   jresult = (void *)result;
13094
13095   //argout typemap for const std::string&
13096
13097   return jresult;
13098 }
13099
13100
13101 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13102   void * jresult ;
13103   Dali::Handle *arg1 = 0 ;
13104   std::string *arg2 = 0 ;
13105   int arg3 ;
13106   Dali::Property *result = 0 ;
13107
13108   arg1 = (Dali::Handle *)jarg1;
13109   if (!arg1) {
13110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13111     return 0;
13112   }
13113   if (!jarg2) {
13114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13115     return 0;
13116   }
13117   std::string arg2_str(jarg2);
13118   arg2 = &arg2_str;
13119   arg3 = (int)jarg3;
13120   {
13121     try {
13122       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13123     } catch (std::out_of_range& e) {
13124       {
13125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13126       };
13127     } catch (std::exception& e) {
13128       {
13129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13130       };
13131     } catch (...) {
13132       {
13133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13134       };
13135     }
13136   }
13137   jresult = (void *)result;
13138
13139   //argout typemap for const std::string&
13140
13141   return jresult;
13142 }
13143
13144
13145 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property(void * jarg1) {
13146   Dali::Property *arg1 = (Dali::Property *) 0 ;
13147
13148   arg1 = (Dali::Property *)jarg1;
13149   {
13150     try {
13151       delete arg1;
13152     } catch (std::out_of_range& e) {
13153       {
13154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13155       };
13156     } catch (std::exception& e) {
13157       {
13158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13163       };
13164     }
13165   }
13166 }
13167
13168
13169 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property__object_set(void * jarg1, void * jarg2) {
13170   Dali::Property *arg1 = (Dali::Property *) 0 ;
13171   Dali::Handle *arg2 = 0 ;
13172
13173   arg1 = (Dali::Property *)jarg1;
13174   arg2 = (Dali::Handle *)jarg2;
13175   if (!arg2) {
13176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13177     return ;
13178   }
13179   if (arg1) (arg1)->object = *arg2;
13180 }
13181
13182
13183 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property__object_get(void * jarg1) {
13184   void * jresult ;
13185   Dali::Property *arg1 = (Dali::Property *) 0 ;
13186   Dali::Handle *result = 0 ;
13187
13188   arg1 = (Dali::Property *)jarg1;
13189   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13190   jresult = (void *)result;
13191   return jresult;
13192 }
13193
13194
13195 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_propertyIndex_set(void * jarg1, int jarg2) {
13196   Dali::Property *arg1 = (Dali::Property *) 0 ;
13197   Dali::Property::Index arg2 ;
13198
13199   arg1 = (Dali::Property *)jarg1;
13200   arg2 = (Dali::Property::Index)jarg2;
13201   if (arg1) (arg1)->propertyIndex = arg2;
13202 }
13203
13204
13205 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_propertyIndex_get(void * jarg1) {
13206   int jresult ;
13207   Dali::Property *arg1 = (Dali::Property *) 0 ;
13208   Dali::Property::Index result;
13209
13210   arg1 = (Dali::Property *)jarg1;
13211   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13212   jresult = result;
13213   return jresult;
13214 }
13215
13216
13217 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_componentIndex_set(void * jarg1, int jarg2) {
13218   Dali::Property *arg1 = (Dali::Property *) 0 ;
13219   int arg2 ;
13220
13221   arg1 = (Dali::Property *)jarg1;
13222   arg2 = (int)jarg2;
13223   if (arg1) (arg1)->componentIndex = arg2;
13224 }
13225
13226
13227 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_componentIndex_get(void * jarg1) {
13228   int jresult ;
13229   Dali::Property *arg1 = (Dali::Property *) 0 ;
13230   int result;
13231
13232   arg1 = (Dali::Property *)jarg1;
13233   result = (int) ((arg1)->componentIndex);
13234   jresult = result;
13235   return jresult;
13236 }
13237
13238
13239 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Array__SWIG_0() {
13240   void * jresult ;
13241   Dali::Property::Array *result = 0 ;
13242
13243   {
13244     try {
13245       result = (Dali::Property::Array *)new Dali::Property::Array();
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13253       };
13254     } catch (...) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13257       };
13258     }
13259   }
13260   jresult = (void *)result;
13261   return jresult;
13262 }
13263
13264
13265 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Array__SWIG_1(void * jarg1) {
13266   void * jresult ;
13267   Dali::Property::Array *arg1 = 0 ;
13268   Dali::Property::Array *result = 0 ;
13269
13270   arg1 = (Dali::Property::Array *)jarg1;
13271   if (!arg1) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13273     return 0;
13274   }
13275   {
13276     try {
13277       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13278     } catch (std::out_of_range& e) {
13279       {
13280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13281       };
13282     } catch (std::exception& e) {
13283       {
13284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13285       };
13286     } catch (...) {
13287       {
13288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13289       };
13290     }
13291   }
13292   jresult = (void *)result;
13293   return jresult;
13294 }
13295
13296
13297 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Array(void * jarg1) {
13298   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13299
13300   arg1 = (Dali::Property::Array *)jarg1;
13301   {
13302     try {
13303       delete arg1;
13304     } catch (std::out_of_range& e) {
13305       {
13306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13307       };
13308     } catch (std::exception& e) {
13309       {
13310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13311       };
13312     } catch (...) {
13313       {
13314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13315       };
13316     }
13317   }
13318 }
13319
13320
13321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Size(void * jarg1) {
13322   unsigned long jresult ;
13323   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13324   Dali::Property::Array::SizeType result;
13325
13326   arg1 = (Dali::Property::Array *)jarg1;
13327   {
13328     try {
13329       result = ((Dali::Property::Array const *)arg1)->Size();
13330     } catch (std::out_of_range& e) {
13331       {
13332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13333       };
13334     } catch (std::exception& e) {
13335       {
13336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13337       };
13338     } catch (...) {
13339       {
13340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13341       };
13342     }
13343   }
13344   jresult = (unsigned long)result;
13345   return jresult;
13346 }
13347
13348
13349 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Count(void * jarg1) {
13350   unsigned long jresult ;
13351   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13352   Dali::Property::Array::SizeType result;
13353
13354   arg1 = (Dali::Property::Array *)jarg1;
13355   {
13356     try {
13357       result = ((Dali::Property::Array const *)arg1)->Count();
13358     } catch (std::out_of_range& e) {
13359       {
13360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13361       };
13362     } catch (std::exception& e) {
13363       {
13364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13365       };
13366     } catch (...) {
13367       {
13368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13369       };
13370     }
13371   }
13372   jresult = (unsigned long)result;
13373   return jresult;
13374 }
13375
13376
13377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Array_Empty(void * jarg1) {
13378   unsigned int jresult ;
13379   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13380   bool result;
13381
13382   arg1 = (Dali::Property::Array *)jarg1;
13383   {
13384     try {
13385       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13386     } catch (std::out_of_range& e) {
13387       {
13388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13389       };
13390     } catch (std::exception& e) {
13391       {
13392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13393       };
13394     } catch (...) {
13395       {
13396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13397       };
13398     }
13399   }
13400   jresult = result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Clear(void * jarg1) {
13406   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13407
13408   arg1 = (Dali::Property::Array *)jarg1;
13409   {
13410     try {
13411       (arg1)->Clear();
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13419       };
13420     } catch (...) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13423       };
13424     }
13425   }
13426 }
13427
13428
13429 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13430   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13431   Dali::Property::Array::SizeType arg2 ;
13432
13433   arg1 = (Dali::Property::Array *)jarg1;
13434   arg2 = (Dali::Property::Array::SizeType)jarg2;
13435   {
13436     try {
13437       (arg1)->Reserve(arg2);
13438     } catch (std::out_of_range& e) {
13439       {
13440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13441       };
13442     } catch (std::exception& e) {
13443       {
13444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13445       };
13446     } catch (...) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13449       };
13450     }
13451   }
13452 }
13453
13454
13455 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13456   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13457   Dali::Property::Array::SizeType arg2 ;
13458
13459   arg1 = (Dali::Property::Array *)jarg1;
13460   arg2 = (Dali::Property::Array::SizeType)jarg2;
13461   {
13462     try {
13463       (arg1)->Resize(arg2);
13464     } catch (std::out_of_range& e) {
13465       {
13466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13467       };
13468     } catch (std::exception& e) {
13469       {
13470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13471       };
13472     } catch (...) {
13473       {
13474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13475       };
13476     }
13477   }
13478 }
13479
13480
13481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Array_Capacity(void * jarg1) {
13482   unsigned long jresult ;
13483   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13484   Dali::Property::Array::SizeType result;
13485
13486   arg1 = (Dali::Property::Array *)jarg1;
13487   {
13488     try {
13489       result = (arg1)->Capacity();
13490     } catch (std::out_of_range& e) {
13491       {
13492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (std::exception& e) {
13495       {
13496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504   jresult = (unsigned long)result;
13505   return jresult;
13506 }
13507
13508
13509 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Array_PushBack(void * jarg1, void * jarg2) {
13510   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13511   Dali::Property::Value *arg2 = 0 ;
13512
13513   arg1 = (Dali::Property::Array *)jarg1;
13514   arg2 = (Dali::Property::Value *)jarg2;
13515   if (!arg2) {
13516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13517     return ;
13518   }
13519   {
13520     try {
13521       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13522     } catch (std::out_of_range& e) {
13523       {
13524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13525       };
13526     } catch (std::exception& e) {
13527       {
13528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13529       };
13530     } catch (...) {
13531       {
13532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13533       };
13534     }
13535   }
13536 }
13537
13538
13539 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_Add(void * jarg1, void * jarg2) {
13540   void * jresult ;
13541   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13542   Dali::Property::Value *arg2 = 0 ;
13543   Dali::Property::Array *result = 0 ;
13544
13545   arg1 = (Dali::Property::Array *)jarg1;
13546   arg2 = (Dali::Property::Value *)jarg2;
13547   if (!arg2) {
13548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13549     return 0;
13550   }
13551   {
13552     try {
13553       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13554     } catch (std::out_of_range& e) {
13555       {
13556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13557       };
13558     } catch (std::exception& e) {
13559       {
13560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13561       };
13562     } catch (...) {
13563       {
13564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13565       };
13566     }
13567   }
13568   jresult = (void *)result;
13569   return jresult;
13570 }
13571
13572
13573 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13574   void * jresult ;
13575   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13576   Dali::Property::Array::SizeType arg2 ;
13577   Dali::Property::Value *result = 0 ;
13578
13579   arg1 = (Dali::Property::Array *)jarg1;
13580   arg2 = (Dali::Property::Array::SizeType)jarg2;
13581   {
13582     try {
13583       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13584     } catch (std::out_of_range& e) {
13585       {
13586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13587       };
13588     } catch (std::exception& e) {
13589       {
13590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13591       };
13592     } catch (...) {
13593       {
13594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13595       };
13596     }
13597   }
13598   jresult = (void *)result;
13599   return jresult;
13600 }
13601
13602
13603 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13604   void * jresult ;
13605   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13606   Dali::Property::Array::SizeType arg2 ;
13607   Dali::Property::Value *result = 0 ;
13608
13609   arg1 = (Dali::Property::Array *)jarg1;
13610   arg2 = (Dali::Property::Array::SizeType)jarg2;
13611   {
13612     try {
13613       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13614     } catch (std::out_of_range& e) {
13615       {
13616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (std::exception& e) {
13619       {
13620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Array_Assign(void * jarg1, void * jarg2) {
13634   void * jresult ;
13635   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13636   Dali::Property::Array *arg2 = 0 ;
13637   Dali::Property::Array *result = 0 ;
13638
13639   arg1 = (Dali::Property::Array *)jarg1;
13640   arg2 = (Dali::Property::Array *)jarg2;
13641   if (!arg2) {
13642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13643     return 0;
13644   }
13645   {
13646     try {
13647       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13648     } catch (std::out_of_range& e) {
13649       {
13650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (std::exception& e) {
13653       {
13654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (...) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13659       };
13660     }
13661   }
13662   jresult = (void *)result;
13663   return jresult;
13664 }
13665
13666
13667 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_type_set(void * jarg1, int jarg2) {
13668   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13669   enum Dali::Property::Key::Type arg2 ;
13670
13671   arg1 = (Dali::Property::Key *)jarg1;
13672   arg2 = (enum Dali::Property::Key::Type)jarg2;
13673   if (arg1) (arg1)->type = arg2;
13674 }
13675
13676
13677 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Key_type_get(void * jarg1) {
13678   int jresult ;
13679   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13680   enum Dali::Property::Key::Type result;
13681
13682   arg1 = (Dali::Property::Key *)jarg1;
13683   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13684   jresult = (int)result;
13685   return jresult;
13686 }
13687
13688
13689 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13690   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13691   Dali::Property::Index arg2 ;
13692
13693   arg1 = (Dali::Property::Key *)jarg1;
13694   arg2 = (Dali::Property::Index)jarg2;
13695   if (arg1) (arg1)->indexKey = arg2;
13696 }
13697
13698
13699 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Key_indexKey_get(void * jarg1) {
13700   int jresult ;
13701   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13702   Dali::Property::Index result;
13703
13704   arg1 = (Dali::Property::Key *)jarg1;
13705   result = (Dali::Property::Index) ((arg1)->indexKey);
13706   jresult = result;
13707   return jresult;
13708 }
13709
13710
13711 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13712   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13713   std::string *arg2 = 0 ;
13714
13715   arg1 = (Dali::Property::Key *)jarg1;
13716   if (!jarg2) {
13717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13718     return ;
13719   }
13720   std::string arg2_str(jarg2);
13721   arg2 = &arg2_str;
13722   if (arg1) (arg1)->stringKey = *arg2;
13723
13724   //argout typemap for const std::string&
13725
13726 }
13727
13728
13729 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Property_Key_stringKey_get(void * jarg1) {
13730   char * jresult ;
13731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13732   std::string *result = 0 ;
13733
13734   arg1 = (Dali::Property::Key *)jarg1;
13735   result = (std::string *) & ((arg1)->stringKey);
13736   jresult = SWIG_csharp_string_callback(result->c_str());
13737   return jresult;
13738 }
13739
13740
13741 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Key__SWIG_0(char * jarg1) {
13742   void * jresult ;
13743   std::string *arg1 = 0 ;
13744   Dali::Property::Key *result = 0 ;
13745
13746   if (!jarg1) {
13747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13748     return 0;
13749   }
13750   std::string arg1_str(jarg1);
13751   arg1 = &arg1_str;
13752   {
13753     try {
13754       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13755     } catch (std::out_of_range& e) {
13756       {
13757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13758       };
13759     } catch (std::exception& e) {
13760       {
13761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13766       };
13767     }
13768   }
13769   jresult = (void *)result;
13770
13771   //argout typemap for const std::string&
13772
13773   return jresult;
13774 }
13775
13776
13777 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Key__SWIG_1(int jarg1) {
13778   void * jresult ;
13779   Dali::Property::Index arg1 ;
13780   Dali::Property::Key *result = 0 ;
13781
13782   arg1 = (Dali::Property::Index)jarg1;
13783   {
13784     try {
13785       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13786     } catch (std::out_of_range& e) {
13787       {
13788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (std::exception& e) {
13791       {
13792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13793       };
13794     } catch (...) {
13795       {
13796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13797       };
13798     }
13799   }
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13806   unsigned int jresult ;
13807   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13808   std::string *arg2 = 0 ;
13809   bool result;
13810
13811   arg1 = (Dali::Property::Key *)jarg1;
13812   if (!jarg2) {
13813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13814     return 0;
13815   }
13816   std::string arg2_str(jarg2);
13817   arg2 = &arg2_str;
13818   {
13819     try {
13820       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13821     } catch (std::out_of_range& e) {
13822       {
13823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (std::exception& e) {
13826       {
13827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835   jresult = result;
13836
13837   //argout typemap for const std::string&
13838
13839   return jresult;
13840 }
13841
13842
13843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13844   unsigned int jresult ;
13845   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13846   Dali::Property::Index arg2 ;
13847   bool result;
13848
13849   arg1 = (Dali::Property::Key *)jarg1;
13850   arg2 = (Dali::Property::Index)jarg2;
13851   {
13852     try {
13853       result = (bool)(arg1)->operator ==(arg2);
13854     } catch (std::out_of_range& e) {
13855       {
13856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (std::exception& e) {
13859       {
13860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868   jresult = result;
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13874   unsigned int jresult ;
13875   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13876   Dali::Property::Key *arg2 = 0 ;
13877   bool result;
13878
13879   arg1 = (Dali::Property::Key *)jarg1;
13880   arg2 = (Dali::Property::Key *)jarg2;
13881   if (!arg2) {
13882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13883     return 0;
13884   }
13885   {
13886     try {
13887       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13888     } catch (std::out_of_range& e) {
13889       {
13890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (std::exception& e) {
13893       {
13894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13895       };
13896     } catch (...) {
13897       {
13898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13899       };
13900     }
13901   }
13902   jresult = result;
13903   return jresult;
13904 }
13905
13906
13907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13908   unsigned int jresult ;
13909   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13910   std::string *arg2 = 0 ;
13911   bool result;
13912
13913   arg1 = (Dali::Property::Key *)jarg1;
13914   if (!jarg2) {
13915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13916     return 0;
13917   }
13918   std::string arg2_str(jarg2);
13919   arg2 = &arg2_str;
13920   {
13921     try {
13922       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13923     } catch (std::out_of_range& e) {
13924       {
13925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (std::exception& e) {
13928       {
13929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13930       };
13931     } catch (...) {
13932       {
13933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13934       };
13935     }
13936   }
13937   jresult = result;
13938
13939   //argout typemap for const std::string&
13940
13941   return jresult;
13942 }
13943
13944
13945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13946   unsigned int jresult ;
13947   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13948   Dali::Property::Index arg2 ;
13949   bool result;
13950
13951   arg1 = (Dali::Property::Key *)jarg1;
13952   arg2 = (Dali::Property::Index)jarg2;
13953   {
13954     try {
13955       result = (bool)(arg1)->operator !=(arg2);
13956     } catch (std::out_of_range& e) {
13957       {
13958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13959       };
13960     } catch (std::exception& e) {
13961       {
13962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13963       };
13964     } catch (...) {
13965       {
13966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13967       };
13968     }
13969   }
13970   jresult = result;
13971   return jresult;
13972 }
13973
13974
13975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13976   unsigned int jresult ;
13977   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13978   Dali::Property::Key *arg2 = 0 ;
13979   bool result;
13980
13981   arg1 = (Dali::Property::Key *)jarg1;
13982   arg2 = (Dali::Property::Key *)jarg2;
13983   if (!arg2) {
13984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13985     return 0;
13986   }
13987   {
13988     try {
13989       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13990     } catch (std::out_of_range& e) {
13991       {
13992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (std::exception& e) {
13995       {
13996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13997       };
13998     } catch (...) {
13999       {
14000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14001       };
14002     }
14003   }
14004   jresult = result;
14005   return jresult;
14006 }
14007
14008
14009 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Key(void * jarg1) {
14010   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14011
14012   arg1 = (Dali::Property::Key *)jarg1;
14013   {
14014     try {
14015       delete arg1;
14016     } catch (std::out_of_range& e) {
14017       {
14018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14019       };
14020     } catch (std::exception& e) {
14021       {
14022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14023       };
14024     } catch (...) {
14025       {
14026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14027       };
14028     }
14029   }
14030 }
14031
14032
14033 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Map__SWIG_0() {
14034   void * jresult ;
14035   Dali::Property::Map *result = 0 ;
14036
14037   {
14038     try {
14039       result = (Dali::Property::Map *)new Dali::Property::Map();
14040     } catch (std::out_of_range& e) {
14041       {
14042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14043       };
14044     } catch (std::exception& e) {
14045       {
14046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14047       };
14048     } catch (...) {
14049       {
14050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14051       };
14052     }
14053   }
14054   jresult = (void *)result;
14055   return jresult;
14056 }
14057
14058
14059 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Map__SWIG_1(void * jarg1) {
14060   void * jresult ;
14061   Dali::Property::Map *arg1 = 0 ;
14062   Dali::Property::Map *result = 0 ;
14063
14064   arg1 = (Dali::Property::Map *)jarg1;
14065   if (!arg1) {
14066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14067     return 0;
14068   }
14069   {
14070     try {
14071       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14072     } catch (std::out_of_range& e) {
14073       {
14074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14075       };
14076     } catch (std::exception& e) {
14077       {
14078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14079       };
14080     } catch (...) {
14081       {
14082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14083       };
14084     }
14085   }
14086   jresult = (void *)result;
14087   return jresult;
14088 }
14089
14090
14091 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Map(void * jarg1) {
14092   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14093
14094   arg1 = (Dali::Property::Map *)jarg1;
14095   {
14096     try {
14097       delete arg1;
14098     } catch (std::out_of_range& e) {
14099       {
14100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14101       };
14102     } catch (std::exception& e) {
14103       {
14104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14105       };
14106     } catch (...) {
14107       {
14108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14109       };
14110     }
14111   }
14112 }
14113
14114
14115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Property_Map_Count(void * jarg1) {
14116   unsigned long jresult ;
14117   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14118   Dali::Property::Map::SizeType result;
14119
14120   arg1 = (Dali::Property::Map *)jarg1;
14121   {
14122     try {
14123       result = ((Dali::Property::Map const *)arg1)->Count();
14124     } catch (std::out_of_range& e) {
14125       {
14126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14127       };
14128     } catch (std::exception& e) {
14129       {
14130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14131       };
14132     } catch (...) {
14133       {
14134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14135       };
14136     }
14137   }
14138   jresult = (unsigned long)result;
14139   return jresult;
14140 }
14141
14142
14143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Map_Empty(void * jarg1) {
14144   unsigned int jresult ;
14145   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14146   bool result;
14147
14148   arg1 = (Dali::Property::Map *)jarg1;
14149   {
14150     try {
14151       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14152     } catch (std::out_of_range& e) {
14153       {
14154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14155       };
14156     } catch (std::exception& e) {
14157       {
14158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14159       };
14160     } catch (...) {
14161       {
14162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14163       };
14164     }
14165   }
14166   jresult = result;
14167   return jresult;
14168 }
14169
14170
14171 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14172   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14173   char *arg2 = (char *) 0 ;
14174   Dali::Property::Value *arg3 = 0 ;
14175
14176   arg1 = (Dali::Property::Map *)jarg1;
14177   arg2 = (char *)jarg2;
14178   arg3 = (Dali::Property::Value *)jarg3;
14179   if (!arg3) {
14180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14181     return ;
14182   }
14183   {
14184     try {
14185       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14186     } catch (std::out_of_range& e) {
14187       {
14188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14189       };
14190     } catch (std::exception& e) {
14191       {
14192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14193       };
14194     } catch (...) {
14195       {
14196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14197       };
14198     }
14199   }
14200 }
14201
14202
14203 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14204   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14205   Dali::Property::Index arg2 ;
14206   Dali::Property::Value *arg3 = 0 ;
14207
14208   arg1 = (Dali::Property::Map *)jarg1;
14209   arg2 = (Dali::Property::Index)jarg2;
14210   arg3 = (Dali::Property::Value *)jarg3;
14211   if (!arg3) {
14212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14213     return ;
14214   }
14215   {
14216     try {
14217       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14218     } catch (std::out_of_range& e) {
14219       {
14220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14221       };
14222     } catch (std::exception& e) {
14223       {
14224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14225       };
14226     } catch (...) {
14227       {
14228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14229       };
14230     }
14231   }
14232 }
14233
14234
14235 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14236   void * jresult ;
14237   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14238   char *arg2 = (char *) 0 ;
14239   Dali::Property::Value *arg3 = 0 ;
14240   Dali::Property::Map *result = 0 ;
14241
14242   arg1 = (Dali::Property::Map *)jarg1;
14243   arg2 = (char *)jarg2;
14244   arg3 = (Dali::Property::Value *)jarg3;
14245   if (!arg3) {
14246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14247     return 0;
14248   }
14249   {
14250     try {
14251       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14252     } catch (std::out_of_range& e) {
14253       {
14254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (std::exception& e) {
14257       {
14258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14259       };
14260     } catch (...) {
14261       {
14262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14263       };
14264     }
14265   }
14266   jresult = (void *)result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14272   void * jresult ;
14273   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14274   Dali::Property::Index arg2 ;
14275   Dali::Property::Value *arg3 = 0 ;
14276   Dali::Property::Map *result = 0 ;
14277
14278   arg1 = (Dali::Property::Map *)jarg1;
14279   arg2 = (Dali::Property::Index)jarg2;
14280   arg3 = (Dali::Property::Value *)jarg3;
14281   if (!arg3) {
14282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14283     return 0;
14284   }
14285   {
14286     try {
14287       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14288     } catch (std::out_of_range& e) {
14289       {
14290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14291       };
14292     } catch (std::exception& e) {
14293       {
14294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14295       };
14296     } catch (...) {
14297       {
14298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14299       };
14300     }
14301   }
14302   jresult = (void *)result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14308   void * jresult ;
14309   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14310   Dali::Property::Map::SizeType arg2 ;
14311   Dali::Property::Value *result = 0 ;
14312
14313   arg1 = (Dali::Property::Map *)jarg1;
14314   arg2 = (Dali::Property::Map::SizeType)jarg2;
14315   {
14316     try {
14317       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332   jresult = (void *)result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14338   char * jresult ;
14339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14340   Dali::Property::Map::SizeType arg2 ;
14341   std::string *result = 0 ;
14342
14343   arg1 = (Dali::Property::Map *)jarg1;
14344   arg2 = (Dali::Property::Map::SizeType)jarg2;
14345   {
14346     try {
14347       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (...) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14359       };
14360     }
14361   }
14362   jresult = SWIG_csharp_string_callback(result->c_str());
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14368   void * jresult ;
14369   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14370   Dali::Property::Map::SizeType arg2 ;
14371   SwigValueWrapper< Dali::Property::Key > result;
14372
14373   arg1 = (Dali::Property::Map *)jarg1;
14374   arg2 = (Dali::Property::Map::SizeType)jarg2;
14375   {
14376     try {
14377       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (...) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14389       };
14390     }
14391   }
14392   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14393   return jresult;
14394 }
14395
14396
14397 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14398   void * jresult ;
14399   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14400   Dali::Property::Map::SizeType arg2 ;
14401   StringValuePair *result = 0 ;
14402
14403   arg1 = (Dali::Property::Map *)jarg1;
14404   arg2 = (Dali::Property::Map::SizeType)jarg2;
14405   {
14406     try {
14407       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14408     } catch (std::out_of_range& e) {
14409       {
14410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14411       };
14412     } catch (std::exception& e) {
14413       {
14414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14415       };
14416     } catch (...) {
14417       {
14418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14419       };
14420     }
14421   }
14422   jresult = (void *)result;
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14428   void * jresult ;
14429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14430   char *arg2 = (char *) 0 ;
14431   Dali::Property::Value *result = 0 ;
14432
14433   arg1 = (Dali::Property::Map *)jarg1;
14434   arg2 = (char *)jarg2;
14435   {
14436     try {
14437       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14438     } catch (std::out_of_range& e) {
14439       {
14440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (std::exception& e) {
14443       {
14444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (...) {
14447       {
14448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14449       };
14450     }
14451   }
14452   jresult = (void *)result;
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   Dali::Property::Index arg2 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   arg2 = (Dali::Property::Index)jarg2;
14465   {
14466     try {
14467       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14468     } catch (std::out_of_range& e) {
14469       {
14470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14471       };
14472     } catch (std::exception& e) {
14473       {
14474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14475       };
14476     } catch (...) {
14477       {
14478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14479       };
14480     }
14481   }
14482   jresult = (void *)result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14488   void * jresult ;
14489   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14490   Dali::Property::Index arg2 ;
14491   std::string *arg3 = 0 ;
14492   Dali::Property::Value *result = 0 ;
14493
14494   arg1 = (Dali::Property::Map *)jarg1;
14495   arg2 = (Dali::Property::Index)jarg2;
14496   if (!jarg3) {
14497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14498     return 0;
14499   }
14500   std::string arg3_str(jarg3);
14501   arg3 = &arg3_str;
14502   {
14503     try {
14504       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14505     } catch (std::out_of_range& e) {
14506       {
14507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14508       };
14509     } catch (std::exception& e) {
14510       {
14511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14512       };
14513     } catch (...) {
14514       {
14515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14516       };
14517     }
14518   }
14519   jresult = (void *)result;
14520
14521   //argout typemap for const std::string&
14522
14523   return jresult;
14524 }
14525
14526
14527 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14528   void * jresult ;
14529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14530   std::string *arg2 = 0 ;
14531   Dali::Property::Type arg3 ;
14532   Dali::Property::Value *result = 0 ;
14533
14534   arg1 = (Dali::Property::Map *)jarg1;
14535   if (!jarg2) {
14536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14537     return 0;
14538   }
14539   std::string arg2_str(jarg2);
14540   arg2 = &arg2_str;
14541   arg3 = (Dali::Property::Type)jarg3;
14542   {
14543     try {
14544       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14545     } catch (std::out_of_range& e) {
14546       {
14547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14548       };
14549     } catch (std::exception& e) {
14550       {
14551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14552       };
14553     } catch (...) {
14554       {
14555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14556       };
14557     }
14558   }
14559   jresult = (void *)result;
14560
14561   //argout typemap for const std::string&
14562
14563   return jresult;
14564 }
14565
14566
14567 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14568   void * jresult ;
14569   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14570   Dali::Property::Index arg2 ;
14571   Dali::Property::Type arg3 ;
14572   Dali::Property::Value *result = 0 ;
14573
14574   arg1 = (Dali::Property::Map *)jarg1;
14575   arg2 = (Dali::Property::Index)jarg2;
14576   arg3 = (Dali::Property::Type)jarg3;
14577   {
14578     try {
14579       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14580     } catch (std::out_of_range& e) {
14581       {
14582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14583       };
14584     } catch (std::exception& e) {
14585       {
14586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14587       };
14588     } catch (...) {
14589       {
14590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14591       };
14592     }
14593   }
14594   jresult = (void *)result;
14595   return jresult;
14596 }
14597
14598
14599 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Clear(void * jarg1) {
14600   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14601
14602   arg1 = (Dali::Property::Map *)jarg1;
14603   {
14604     try {
14605       (arg1)->Clear();
14606     } catch (std::out_of_range& e) {
14607       {
14608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14609       };
14610     } catch (std::exception& e) {
14611       {
14612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14613       };
14614     } catch (...) {
14615       {
14616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14617       };
14618     }
14619   }
14620 }
14621
14622
14623 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Property_Map_Merge(void * jarg1, void * jarg2) {
14624   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14625   Dali::Property::Map *arg2 = 0 ;
14626
14627   arg1 = (Dali::Property::Map *)jarg1;
14628   arg2 = (Dali::Property::Map *)jarg2;
14629   if (!arg2) {
14630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14631     return ;
14632   }
14633   {
14634     try {
14635       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14643       };
14644     } catch (...) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14647       };
14648     }
14649   }
14650 }
14651
14652
14653 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14654   void * jresult ;
14655   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14656   std::string *arg2 = 0 ;
14657   Dali::Property::Value *result = 0 ;
14658
14659   arg1 = (Dali::Property::Map *)jarg1;
14660   if (!jarg2) {
14661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14662     return 0;
14663   }
14664   std::string arg2_str(jarg2);
14665   arg2 = &arg2_str;
14666   {
14667     try {
14668       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14669     } catch (std::out_of_range& e) {
14670       {
14671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14672       };
14673     } catch (std::exception& e) {
14674       {
14675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14676       };
14677     } catch (...) {
14678       {
14679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14680       };
14681     }
14682   }
14683   jresult = (void *)result;
14684
14685   //argout typemap for const std::string&
14686
14687   return jresult;
14688 }
14689
14690
14691 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14692   void * jresult ;
14693   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14694   Dali::Property::Index arg2 ;
14695   Dali::Property::Value *result = 0 ;
14696
14697   arg1 = (Dali::Property::Map *)jarg1;
14698   arg2 = (Dali::Property::Index)jarg2;
14699   {
14700     try {
14701       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14702     } catch (std::out_of_range& e) {
14703       {
14704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14705       };
14706     } catch (std::exception& e) {
14707       {
14708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14709       };
14710     } catch (...) {
14711       {
14712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14713       };
14714     }
14715   }
14716   jresult = (void *)result;
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Map_Assign(void * jarg1, void * jarg2) {
14722   void * jresult ;
14723   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14724   Dali::Property::Map *arg2 = 0 ;
14725   Dali::Property::Map *result = 0 ;
14726
14727   arg1 = (Dali::Property::Map *)jarg1;
14728   arg2 = (Dali::Property::Map *)jarg2;
14729   if (!arg2) {
14730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14731     return 0;
14732   }
14733   {
14734     try {
14735       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14736     } catch (std::out_of_range& e) {
14737       {
14738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (std::exception& e) {
14741       {
14742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14743       };
14744     } catch (...) {
14745       {
14746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14747       };
14748     }
14749   }
14750   jresult = (void *)result;
14751   return jresult;
14752 }
14753
14754
14755 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_0() {
14756   void * jresult ;
14757   Dali::Property::Value *result = 0 ;
14758
14759   {
14760     try {
14761       result = (Dali::Property::Value *)new Dali::Property::Value();
14762     } catch (std::out_of_range& e) {
14763       {
14764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14765       };
14766     } catch (std::exception& e) {
14767       {
14768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (...) {
14771       {
14772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14773       };
14774     }
14775   }
14776   jresult = (void *)result;
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_1(unsigned int jarg1) {
14782   void * jresult ;
14783   bool arg1 ;
14784   Dali::Property::Value *result = 0 ;
14785
14786   arg1 = jarg1 ? true : false;
14787   {
14788     try {
14789       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14790     } catch (std::out_of_range& e) {
14791       {
14792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14793       };
14794     } catch (std::exception& e) {
14795       {
14796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14797       };
14798     } catch (...) {
14799       {
14800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14801       };
14802     }
14803   }
14804   jresult = (void *)result;
14805   return jresult;
14806 }
14807
14808
14809 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_2(int jarg1) {
14810   void * jresult ;
14811   int arg1 ;
14812   Dali::Property::Value *result = 0 ;
14813
14814   arg1 = (int)jarg1;
14815   {
14816     try {
14817       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14818     } catch (std::out_of_range& e) {
14819       {
14820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14821       };
14822     } catch (std::exception& e) {
14823       {
14824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14825       };
14826     } catch (...) {
14827       {
14828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14829       };
14830     }
14831   }
14832   jresult = (void *)result;
14833   return jresult;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_3(float jarg1) {
14838   void * jresult ;
14839   float arg1 ;
14840   Dali::Property::Value *result = 0 ;
14841
14842   arg1 = (float)jarg1;
14843   {
14844     try {
14845       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14846     } catch (std::out_of_range& e) {
14847       {
14848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14849       };
14850     } catch (std::exception& e) {
14851       {
14852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14853       };
14854     } catch (...) {
14855       {
14856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14857       };
14858     }
14859   }
14860   jresult = (void *)result;
14861   return jresult;
14862 }
14863
14864
14865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_4(void * jarg1) {
14866   void * jresult ;
14867   Dali::Vector2 *arg1 = 0 ;
14868   Dali::Property::Value *result = 0 ;
14869
14870   arg1 = (Dali::Vector2 *)jarg1;
14871   if (!arg1) {
14872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14873     return 0;
14874   }
14875   {
14876     try {
14877       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14878     } catch (std::out_of_range& e) {
14879       {
14880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14881       };
14882     } catch (std::exception& e) {
14883       {
14884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14885       };
14886     } catch (...) {
14887       {
14888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14889       };
14890     }
14891   }
14892   jresult = (void *)result;
14893   return jresult;
14894 }
14895
14896
14897 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_5(void * jarg1) {
14898   void * jresult ;
14899   Dali::Vector3 *arg1 = 0 ;
14900   Dali::Property::Value *result = 0 ;
14901
14902   arg1 = (Dali::Vector3 *)jarg1;
14903   if (!arg1) {
14904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14905     return 0;
14906   }
14907   {
14908     try {
14909       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14910     } catch (std::out_of_range& e) {
14911       {
14912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14913       };
14914     } catch (std::exception& e) {
14915       {
14916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14917       };
14918     } catch (...) {
14919       {
14920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14921       };
14922     }
14923   }
14924   jresult = (void *)result;
14925   return jresult;
14926 }
14927
14928
14929 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_6(void * jarg1) {
14930   void * jresult ;
14931   Dali::Vector4 *arg1 = 0 ;
14932   Dali::Property::Value *result = 0 ;
14933
14934   arg1 = (Dali::Vector4 *)jarg1;
14935   if (!arg1) {
14936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14937     return 0;
14938   }
14939   {
14940     try {
14941       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14942     } catch (std::out_of_range& e) {
14943       {
14944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (std::exception& e) {
14947       {
14948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14953       };
14954     }
14955   }
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_7(void * jarg1) {
14962   void * jresult ;
14963   Dali::Matrix3 *arg1 = 0 ;
14964   Dali::Property::Value *result = 0 ;
14965
14966   arg1 = (Dali::Matrix3 *)jarg1;
14967   if (!arg1) {
14968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14969     return 0;
14970   }
14971   {
14972     try {
14973       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14974     } catch (std::out_of_range& e) {
14975       {
14976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14977       };
14978     } catch (std::exception& e) {
14979       {
14980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14981       };
14982     } catch (...) {
14983       {
14984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14985       };
14986     }
14987   }
14988   jresult = (void *)result;
14989   return jresult;
14990 }
14991
14992
14993 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_8(void * jarg1) {
14994   void * jresult ;
14995   Dali::Matrix *arg1 = 0 ;
14996   Dali::Property::Value *result = 0 ;
14997
14998   arg1 = (Dali::Matrix *)jarg1;
14999   if (!arg1) {
15000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15001     return 0;
15002   }
15003   {
15004     try {
15005       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15006     } catch (std::out_of_range& e) {
15007       {
15008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (std::exception& e) {
15011       {
15012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020   jresult = (void *)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_9(void * jarg1) {
15026   void * jresult ;
15027   Dali::Rect< int > *arg1 = 0 ;
15028   Dali::Property::Value *result = 0 ;
15029
15030   arg1 = (Dali::Rect< int > *)jarg1;
15031   if (!arg1) {
15032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15033     return 0;
15034   }
15035   {
15036     try {
15037       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15038     } catch (std::out_of_range& e) {
15039       {
15040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15041       };
15042     } catch (std::exception& e) {
15043       {
15044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15045       };
15046     } catch (...) {
15047       {
15048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15049       };
15050     }
15051   }
15052   jresult = (void *)result;
15053   return jresult;
15054 }
15055
15056
15057 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_10(void * jarg1) {
15058   void * jresult ;
15059   Dali::AngleAxis *arg1 = 0 ;
15060   Dali::Property::Value *result = 0 ;
15061
15062   arg1 = (Dali::AngleAxis *)jarg1;
15063   if (!arg1) {
15064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15065     return 0;
15066   }
15067   {
15068     try {
15069       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15070     } catch (std::out_of_range& e) {
15071       {
15072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (std::exception& e) {
15075       {
15076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15081       };
15082     }
15083   }
15084   jresult = (void *)result;
15085   return jresult;
15086 }
15087
15088
15089 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_11(void * jarg1) {
15090   void * jresult ;
15091   Dali::Quaternion *arg1 = 0 ;
15092   Dali::Property::Value *result = 0 ;
15093
15094   arg1 = (Dali::Quaternion *)jarg1;
15095   if (!arg1) {
15096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15097     return 0;
15098   }
15099   {
15100     try {
15101       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15102     } catch (std::out_of_range& e) {
15103       {
15104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15105       };
15106     } catch (std::exception& e) {
15107       {
15108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15109       };
15110     } catch (...) {
15111       {
15112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15113       };
15114     }
15115   }
15116   jresult = (void *)result;
15117   return jresult;
15118 }
15119
15120
15121 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_12(char * jarg1) {
15122   void * jresult ;
15123   std::string *arg1 = 0 ;
15124   Dali::Property::Value *result = 0 ;
15125
15126   if (!jarg1) {
15127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15128     return 0;
15129   }
15130   std::string arg1_str(jarg1);
15131   arg1 = &arg1_str;
15132   {
15133     try {
15134       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15135     } catch (std::out_of_range& e) {
15136       {
15137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15138       };
15139     } catch (std::exception& e) {
15140       {
15141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15142       };
15143     } catch (...) {
15144       {
15145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15146       };
15147     }
15148   }
15149   jresult = (void *)result;
15150
15151   //argout typemap for const std::string&
15152
15153   return jresult;
15154 }
15155
15156
15157 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_14(void * jarg1) {
15158   void * jresult ;
15159   Dali::Property::Array *arg1 = 0 ;
15160   Dali::Property::Value *result = 0 ;
15161
15162   arg1 = (Dali::Property::Array *)jarg1;
15163   if (!arg1) {
15164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15165     return 0;
15166   }
15167   {
15168     try {
15169       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15170     } catch (std::out_of_range& e) {
15171       {
15172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15173       };
15174     } catch (std::exception& e) {
15175       {
15176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15177       };
15178     } catch (...) {
15179       {
15180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15181       };
15182     }
15183   }
15184   jresult = (void *)result;
15185   return jresult;
15186 }
15187
15188
15189 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_15(void * jarg1) {
15190   void * jresult ;
15191   Dali::Property::Map *arg1 = 0 ;
15192   Dali::Property::Value *result = 0 ;
15193
15194   arg1 = (Dali::Property::Map *)jarg1;
15195   if (!arg1) {
15196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15197     return 0;
15198   }
15199   {
15200     try {
15201       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15202     } catch (std::out_of_range& e) {
15203       {
15204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15205       };
15206     } catch (std::exception& e) {
15207       {
15208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15209       };
15210     } catch (...) {
15211       {
15212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15213       };
15214     }
15215   }
15216   jresult = (void *)result;
15217   return jresult;
15218 }
15219
15220
15221 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_16(int jarg1) {
15222   void * jresult ;
15223   Dali::Property::Type arg1 ;
15224   Dali::Property::Value *result = 0 ;
15225
15226   arg1 = (Dali::Property::Type)jarg1;
15227   {
15228     try {
15229       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15230     } catch (std::out_of_range& e) {
15231       {
15232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15233       };
15234     } catch (std::exception& e) {
15235       {
15236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15241       };
15242     }
15243   }
15244   jresult = (void *)result;
15245   return jresult;
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Property_Value__SWIG_17(void * jarg1) {
15250   void * jresult ;
15251   Dali::Property::Value *arg1 = 0 ;
15252   Dali::Property::Value *result = 0 ;
15253
15254   arg1 = (Dali::Property::Value *)jarg1;
15255   if (!arg1) {
15256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15257     return 0;
15258   }
15259   {
15260     try {
15261       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15262     } catch (std::out_of_range& e) {
15263       {
15264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15265       };
15266     } catch (std::exception& e) {
15267       {
15268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (...) {
15271       {
15272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15273       };
15274     }
15275   }
15276   jresult = (void *)result;
15277   return jresult;
15278 }
15279
15280
15281 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_Assign(void * jarg1, void * jarg2) {
15282   void * jresult ;
15283   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15284   Dali::Property::Value *arg2 = 0 ;
15285   Dali::Property::Value *result = 0 ;
15286
15287   arg1 = (Dali::Property::Value *)jarg1;
15288   arg2 = (Dali::Property::Value *)jarg2;
15289   if (!arg2) {
15290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15291     return 0;
15292   }
15293   {
15294     try {
15295       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15296     } catch (std::out_of_range& e) {
15297       {
15298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (std::exception& e) {
15301       {
15302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15303       };
15304     } catch (...) {
15305       {
15306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15307       };
15308     }
15309   }
15310   jresult = (void *)result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Property_Value(void * jarg1) {
15316   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15317
15318   arg1 = (Dali::Property::Value *)jarg1;
15319   {
15320     try {
15321       delete arg1;
15322     } catch (std::out_of_range& e) {
15323       {
15324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15325       };
15326     } catch (std::exception& e) {
15327       {
15328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15329       };
15330     } catch (...) {
15331       {
15332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15333       };
15334     }
15335   }
15336 }
15337
15338
15339 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Property_Value_GetType(void * jarg1) {
15340   int jresult ;
15341   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15342   Dali::Property::Type result;
15343
15344   arg1 = (Dali::Property::Value *)jarg1;
15345   {
15346     try {
15347       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15348     } catch (std::out_of_range& e) {
15349       {
15350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15351       };
15352     } catch (std::exception& e) {
15353       {
15354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15355       };
15356     } catch (...) {
15357       {
15358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15359       };
15360     }
15361   }
15362   jresult = (int)result;
15363   return jresult;
15364 }
15365
15366
15367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15368   unsigned int jresult ;
15369   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15370   bool *arg2 = 0 ;
15371   bool result;
15372
15373   arg1 = (Dali::Property::Value *)jarg1;
15374   arg2 = (bool *)jarg2;
15375   {
15376     try {
15377       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15378     } catch (std::out_of_range& e) {
15379       {
15380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (std::exception& e) {
15383       {
15384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15385       };
15386     } catch (...) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15389       };
15390     }
15391   }
15392   jresult = result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15398   unsigned int jresult ;
15399   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15400   float *arg2 = 0 ;
15401   bool result;
15402
15403   arg1 = (Dali::Property::Value *)jarg1;
15404   arg2 = (float *)jarg2;
15405   {
15406     try {
15407       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15408     } catch (std::out_of_range& e) {
15409       {
15410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15411       };
15412     } catch (std::exception& e) {
15413       {
15414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15415       };
15416     } catch (...) {
15417       {
15418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15419       };
15420     }
15421   }
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15428   unsigned int jresult ;
15429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15430   int *arg2 = 0 ;
15431   bool result;
15432
15433   arg1 = (Dali::Property::Value *)jarg1;
15434   arg2 = (int *)jarg2;
15435   {
15436     try {
15437       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (...) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15449       };
15450     }
15451   }
15452   jresult = result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15458   unsigned int jresult ;
15459   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15460   Dali::Rect< int > *arg2 = 0 ;
15461   bool result;
15462
15463   arg1 = (Dali::Property::Value *)jarg1;
15464   arg2 = (Dali::Rect< int > *)jarg2;
15465   if (!arg2) {
15466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15467     return 0;
15468   }
15469   {
15470     try {
15471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15472     } catch (std::out_of_range& e) {
15473       {
15474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (std::exception& e) {
15477       {
15478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15479       };
15480     } catch (...) {
15481       {
15482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15483       };
15484     }
15485   }
15486   jresult = result;
15487   return jresult;
15488 }
15489
15490
15491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15492   unsigned int jresult ;
15493   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15494   Dali::Vector2 *arg2 = 0 ;
15495   bool result;
15496
15497   arg1 = (Dali::Property::Value *)jarg1;
15498   arg2 = (Dali::Vector2 *)jarg2;
15499   if (!arg2) {
15500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15501     return 0;
15502   }
15503   {
15504     try {
15505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15506     } catch (std::out_of_range& e) {
15507       {
15508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15509       };
15510     } catch (std::exception& e) {
15511       {
15512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15513       };
15514     } catch (...) {
15515       {
15516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15517       };
15518     }
15519   }
15520   jresult = result;
15521   return jresult;
15522 }
15523
15524
15525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15526   unsigned int jresult ;
15527   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15528   Dali::Vector3 *arg2 = 0 ;
15529   bool result;
15530
15531   arg1 = (Dali::Property::Value *)jarg1;
15532   arg2 = (Dali::Vector3 *)jarg2;
15533   if (!arg2) {
15534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15535     return 0;
15536   }
15537   {
15538     try {
15539       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15540     } catch (std::out_of_range& e) {
15541       {
15542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (std::exception& e) {
15545       {
15546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15547       };
15548     } catch (...) {
15549       {
15550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15551       };
15552     }
15553   }
15554   jresult = result;
15555   return jresult;
15556 }
15557
15558
15559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15560   unsigned int jresult ;
15561   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15562   Dali::Vector4 *arg2 = 0 ;
15563   bool result;
15564
15565   arg1 = (Dali::Property::Value *)jarg1;
15566   arg2 = (Dali::Vector4 *)jarg2;
15567   if (!arg2) {
15568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15569     return 0;
15570   }
15571   {
15572     try {
15573       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15574     } catch (std::out_of_range& e) {
15575       {
15576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15577       };
15578     } catch (std::exception& e) {
15579       {
15580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15581       };
15582     } catch (...) {
15583       {
15584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15585       };
15586     }
15587   }
15588   jresult = result;
15589   return jresult;
15590 }
15591
15592
15593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15594   unsigned int jresult ;
15595   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15596   Dali::Matrix3 *arg2 = 0 ;
15597   bool result;
15598
15599   arg1 = (Dali::Property::Value *)jarg1;
15600   arg2 = (Dali::Matrix3 *)jarg2;
15601   if (!arg2) {
15602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15603     return 0;
15604   }
15605   {
15606     try {
15607       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15608     } catch (std::out_of_range& e) {
15609       {
15610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (std::exception& e) {
15613       {
15614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15615       };
15616     } catch (...) {
15617       {
15618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15619       };
15620     }
15621   }
15622   jresult = result;
15623   return jresult;
15624 }
15625
15626
15627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15628   unsigned int jresult ;
15629   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15630   Dali::Matrix *arg2 = 0 ;
15631   bool result;
15632
15633   arg1 = (Dali::Property::Value *)jarg1;
15634   arg2 = (Dali::Matrix *)jarg2;
15635   if (!arg2) {
15636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15637     return 0;
15638   }
15639   {
15640     try {
15641       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15642     } catch (std::out_of_range& e) {
15643       {
15644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (std::exception& e) {
15647       {
15648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15649       };
15650     } catch (...) {
15651       {
15652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15653       };
15654     }
15655   }
15656   jresult = result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15662   unsigned int jresult ;
15663   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15664   Dali::AngleAxis *arg2 = 0 ;
15665   bool result;
15666
15667   arg1 = (Dali::Property::Value *)jarg1;
15668   arg2 = (Dali::AngleAxis *)jarg2;
15669   if (!arg2) {
15670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15671     return 0;
15672   }
15673   {
15674     try {
15675       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15676     } catch (std::out_of_range& e) {
15677       {
15678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (std::exception& e) {
15681       {
15682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (...) {
15685       {
15686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15687       };
15688     }
15689   }
15690   jresult = result;
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15696   unsigned int jresult ;
15697   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15698   Dali::Quaternion *arg2 = 0 ;
15699   bool result;
15700
15701   arg1 = (Dali::Property::Value *)jarg1;
15702   arg2 = (Dali::Quaternion *)jarg2;
15703   if (!arg2) {
15704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15705     return 0;
15706   }
15707   {
15708     try {
15709       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (...) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15721       };
15722     }
15723   }
15724   jresult = result;
15725   return jresult;
15726 }
15727
15728
15729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15730   unsigned int jresult ;
15731   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15732   std::string *arg2 = 0 ;
15733   bool result;
15734
15735   arg1 = (Dali::Property::Value *)jarg1;
15736
15737   //typemap in
15738   std::string temp;
15739   arg2 = &temp;
15740
15741   {
15742     try {
15743       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15744     } catch (std::out_of_range& e) {
15745       {
15746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (std::exception& e) {
15749       {
15750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15751       };
15752     } catch (...) {
15753       {
15754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15755       };
15756     }
15757   }
15758   jresult = result;
15759
15760   //Typemap argout in c++ file.
15761   //This will convert c++ string to c# string
15762   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15763
15764   return jresult;
15765 }
15766
15767
15768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15769   unsigned int jresult ;
15770   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15771   Dali::Property::Array *arg2 = 0 ;
15772   bool result;
15773
15774   arg1 = (Dali::Property::Value *)jarg1;
15775   arg2 = (Dali::Property::Array *)jarg2;
15776   if (!arg2) {
15777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15778     return 0;
15779   }
15780   {
15781     try {
15782       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15783     } catch (std::out_of_range& e) {
15784       {
15785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15786       };
15787     } catch (std::exception& e) {
15788       {
15789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15790       };
15791     } catch (...) {
15792       {
15793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15794       };
15795     }
15796   }
15797   jresult = result;
15798   return jresult;
15799 }
15800
15801
15802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15803   unsigned int jresult ;
15804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15805   Dali::Property::Map *arg2 = 0 ;
15806   bool result;
15807
15808   arg1 = (Dali::Property::Value *)jarg1;
15809   arg2 = (Dali::Property::Map *)jarg2;
15810   if (!arg2) {
15811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15812     return 0;
15813   }
15814   {
15815     try {
15816       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (...) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15828       };
15829     }
15830   }
15831   jresult = result;
15832   return jresult;
15833 }
15834
15835
15836 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_GetArray(void * jarg1) {
15837   void * jresult ;
15838   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15839   Dali::Property::Array *result = 0 ;
15840
15841   arg1 = (Dali::Property::Value *)jarg1;
15842   {
15843     try {
15844       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15845     } catch (std::out_of_range& e) {
15846       {
15847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15848       };
15849     } catch (std::exception& e) {
15850       {
15851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15852       };
15853     } catch (...) {
15854       {
15855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15856       };
15857     }
15858   }
15859   jresult = (void *)result;
15860   return jresult;
15861 }
15862
15863
15864 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Property_Value_GetMap(void * jarg1) {
15865   void * jresult ;
15866   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15867   Dali::Property::Map *result = 0 ;
15868
15869   arg1 = (Dali::Property::Value *)jarg1;
15870   {
15871     try {
15872       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15873     } catch (std::out_of_range& e) {
15874       {
15875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15876       };
15877     } catch (std::exception& e) {
15878       {
15879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15884       };
15885     }
15886   }
15887   jresult = (void *)result;
15888   return jresult;
15889 }
15890
15891
15892 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_GetName(int jarg1) {
15893   char * jresult ;
15894   Dali::Property::Type arg1 ;
15895   char *result = 0 ;
15896
15897   arg1 = (Dali::Property::Type)jarg1;
15898   {
15899     try {
15900       result = (char *)Dali::PropertyTypes::GetName(arg1);
15901     } catch (std::out_of_range& e) {
15902       {
15903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15904       };
15905     } catch (std::exception& e) {
15906       {
15907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15908       };
15909     } catch (...) {
15910       {
15911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15912       };
15913     }
15914   }
15915   jresult = SWIG_csharp_string_callback((const char *)result);
15916   return jresult;
15917 }
15918
15919
15920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15921   unsigned int jresult ;
15922   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15923   std::string *arg2 = 0 ;
15924   Dali::Property::Map *arg3 = 0 ;
15925   bool result;
15926
15927   arg1 = (Dali::BaseObject *)jarg1;
15928   if (!jarg2) {
15929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15930     return 0;
15931   }
15932   std::string arg2_str(jarg2);
15933   arg2 = &arg2_str;
15934   arg3 = (Dali::Property::Map *)jarg3;
15935   if (!arg3) {
15936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15937     return 0;
15938   }
15939   {
15940     try {
15941       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15942     } catch (std::out_of_range& e) {
15943       {
15944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15945       };
15946     } catch (std::exception& e) {
15947       {
15948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15949       };
15950     } catch (...) {
15951       {
15952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15953       };
15954     }
15955   }
15956   jresult = result;
15957
15958   //argout typemap for const std::string&
15959
15960   return jresult;
15961 }
15962
15963
15964 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_BaseObject_GetTypeName(void * jarg1) {
15965   char * jresult ;
15966   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15967   std::string *result = 0 ;
15968
15969   arg1 = (Dali::BaseObject *)jarg1;
15970   {
15971     try {
15972       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15973     } catch (std::out_of_range& e) {
15974       {
15975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15976       };
15977     } catch (std::exception& e) {
15978       {
15979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15980       };
15981     } catch (...) {
15982       {
15983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15984       };
15985     }
15986   }
15987   jresult = SWIG_csharp_string_callback(result->c_str());
15988   return jresult;
15989 }
15990
15991
15992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15993   unsigned int jresult ;
15994   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15995   Dali::TypeInfo *arg2 = 0 ;
15996   bool result;
15997
15998   arg1 = (Dali::BaseObject *)jarg1;
15999   arg2 = (Dali::TypeInfo *)jarg2;
16000   if (!arg2) {
16001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16002     return 0;
16003   }
16004   {
16005     try {
16006       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16007     } catch (std::out_of_range& e) {
16008       {
16009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16010       };
16011     } catch (std::exception& e) {
16012       {
16013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16014       };
16015     } catch (...) {
16016       {
16017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16018       };
16019     }
16020   }
16021   jresult = result;
16022   return jresult;
16023 }
16024
16025
16026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16027   unsigned int jresult ;
16028   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16029   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16030   std::string *arg3 = 0 ;
16031   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16032   bool result;
16033
16034   arg1 = (Dali::BaseObject *)jarg1;
16035   arg2 = (ConnectionTrackerInterface *)jarg2;
16036   if (!jarg3) {
16037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16038     return 0;
16039   }
16040   std::string arg3_str(jarg3);
16041   arg3 = &arg3_str;
16042   arg4 = (FunctorDelegate *)jarg4;
16043   {
16044     try {
16045       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16046     } catch (std::out_of_range& e) {
16047       {
16048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16049       };
16050     } catch (std::exception& e) {
16051       {
16052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16053       };
16054     } catch (...) {
16055       {
16056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16057       };
16058     }
16059   }
16060   jresult = result;
16061
16062   //argout typemap for const std::string&
16063
16064   return jresult;
16065 }
16066
16067
16068 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GetImplementation(void * jarg1) {
16069   void * jresult ;
16070   Dali::BaseHandle *arg1 = 0 ;
16071   Dali::BaseObject *result = 0 ;
16072
16073   arg1 = (Dali::BaseHandle *)jarg1;
16074   if (!arg1) {
16075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16076     return 0;
16077   }
16078   {
16079     try {
16080       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16081     } catch (std::out_of_range& e) {
16082       {
16083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16084       };
16085     } catch (std::exception& e) {
16086       {
16087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16088       };
16089     } catch (...) {
16090       {
16091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16092       };
16093     }
16094   }
16095   jresult = (void *)result;
16096   return jresult;
16097 }
16098
16099
16100 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_0(void * jarg1) {
16101   void * jresult ;
16102   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16103   Dali::BaseHandle *result = 0 ;
16104
16105   arg1 = (Dali::BaseObject *)jarg1;
16106   {
16107     try {
16108       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16109     } catch (std::out_of_range& e) {
16110       {
16111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (std::exception& e) {
16114       {
16115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123   jresult = (void *)result;
16124   return jresult;
16125 }
16126
16127
16128 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_1() {
16129   void * jresult ;
16130   Dali::BaseHandle *result = 0 ;
16131
16132   {
16133     try {
16134       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16135     } catch (std::out_of_range& e) {
16136       {
16137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16138       };
16139     } catch (std::exception& e) {
16140       {
16141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (...) {
16144       {
16145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16146       };
16147     }
16148   }
16149   jresult = (void *)result;
16150   return jresult;
16151 }
16152
16153
16154 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BaseHandle(void * jarg1) {
16155   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16156
16157   arg1 = (Dali::BaseHandle *)jarg1;
16158   {
16159     try {
16160       delete arg1;
16161     } catch (std::out_of_range& e) {
16162       {
16163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16164       };
16165     } catch (std::exception& e) {
16166       {
16167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16168       };
16169     } catch (...) {
16170       {
16171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16172       };
16173     }
16174   }
16175 }
16176
16177
16178 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BaseHandle__SWIG_2(void * jarg1) {
16179   void * jresult ;
16180   Dali::BaseHandle *arg1 = 0 ;
16181   Dali::BaseHandle *result = 0 ;
16182
16183   arg1 = (Dali::BaseHandle *)jarg1;
16184   if (!arg1) {
16185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16186     return 0;
16187   }
16188   {
16189     try {
16190       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16191     } catch (std::out_of_range& e) {
16192       {
16193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16194       };
16195     } catch (std::exception& e) {
16196       {
16197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16198       };
16199     } catch (...) {
16200       {
16201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16202       };
16203     }
16204   }
16205   jresult = (void *)result;
16206   return jresult;
16207 }
16208
16209
16210 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_Assign(void * jarg1, void * jarg2) {
16211   void * jresult ;
16212   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16213   Dali::BaseHandle *arg2 = 0 ;
16214   Dali::BaseHandle *result = 0 ;
16215
16216   arg1 = (Dali::BaseHandle *)jarg1;
16217   arg2 = (Dali::BaseHandle *)jarg2;
16218   if (!arg2) {
16219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16220     return 0;
16221   }
16222   {
16223     try {
16224       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16225     } catch (std::out_of_range& e) {
16226       {
16227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (std::exception& e) {
16230       {
16231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16232       };
16233     } catch (...) {
16234       {
16235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16236       };
16237     }
16238   }
16239   jresult = (void *)result;
16240   return jresult;
16241 }
16242
16243
16244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16245   unsigned int jresult ;
16246   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16247   std::string *arg2 = 0 ;
16248   Dali::Property::Map *arg3 = 0 ;
16249   bool result;
16250
16251   arg1 = (Dali::BaseHandle *)jarg1;
16252   if (!jarg2) {
16253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16254     return 0;
16255   }
16256   std::string arg2_str(jarg2);
16257   arg2 = &arg2_str;
16258   arg3 = (Dali::Property::Map *)jarg3;
16259   if (!arg3) {
16260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16261     return 0;
16262   }
16263   {
16264     try {
16265       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16266     } catch (std::out_of_range& e) {
16267       {
16268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16269       };
16270     } catch (std::exception& e) {
16271       {
16272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16273       };
16274     } catch (...) {
16275       {
16276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16277       };
16278     }
16279   }
16280   jresult = result;
16281
16282   //argout typemap for const std::string&
16283
16284   return jresult;
16285 }
16286
16287
16288 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_BaseHandle_GetTypeName(void * jarg1) {
16289   char * jresult ;
16290   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16291   std::string *result = 0 ;
16292
16293   arg1 = (Dali::BaseHandle *)jarg1;
16294   {
16295     try {
16296       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16297     } catch (std::out_of_range& e) {
16298       {
16299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16300       };
16301     } catch (std::exception& e) {
16302       {
16303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16304       };
16305     } catch (...) {
16306       {
16307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16308       };
16309     }
16310   }
16311   jresult = SWIG_csharp_string_callback(result->c_str());
16312   return jresult;
16313 }
16314
16315
16316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16317   unsigned int jresult ;
16318   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16319   Dali::TypeInfo *arg2 = 0 ;
16320   bool result;
16321
16322   arg1 = (Dali::BaseHandle *)jarg1;
16323   arg2 = (Dali::TypeInfo *)jarg2;
16324   if (!arg2) {
16325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16326     return 0;
16327   }
16328   {
16329     try {
16330       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16331     } catch (std::out_of_range& e) {
16332       {
16333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16334       };
16335     } catch (std::exception& e) {
16336       {
16337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16338       };
16339     } catch (...) {
16340       {
16341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16342       };
16343     }
16344   }
16345   jresult = result;
16346   return jresult;
16347 }
16348
16349
16350 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16351   void * jresult ;
16352   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16353   Dali::BaseObject *result = 0 ;
16354
16355   arg1 = (Dali::BaseHandle *)jarg1;
16356   {
16357     try {
16358       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16359     } catch (std::out_of_range& e) {
16360       {
16361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (std::exception& e) {
16364       {
16365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373   jresult = (void *)result;
16374   return jresult;
16375 }
16376
16377
16378 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BaseHandle_Reset(void * jarg1) {
16379   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16380
16381   arg1 = (Dali::BaseHandle *)jarg1;
16382   {
16383     try {
16384       (arg1)->Reset();
16385     } catch (std::out_of_range& e) {
16386       {
16387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16388       };
16389     } catch (std::exception& e) {
16390       {
16391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16392       };
16393     } catch (...) {
16394       {
16395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16396       };
16397     }
16398   }
16399 }
16400
16401
16402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16403   unsigned int jresult ;
16404   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16405   Dali::BaseHandle *arg2 = 0 ;
16406   bool result;
16407
16408   arg1 = (Dali::BaseHandle *)jarg1;
16409   arg2 = (Dali::BaseHandle *)jarg2;
16410   if (!arg2) {
16411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16412     return 0;
16413   }
16414   {
16415     try {
16416       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16417     } catch (std::out_of_range& e) {
16418       {
16419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16420       };
16421     } catch (std::exception& e) {
16422       {
16423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16424       };
16425     } catch (...) {
16426       {
16427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16428       };
16429     }
16430   }
16431   jresult = result;
16432   return jresult;
16433 }
16434
16435
16436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16437   unsigned int jresult ;
16438   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16439   Dali::BaseHandle *arg2 = 0 ;
16440   bool result;
16441
16442   arg1 = (Dali::BaseHandle *)jarg1;
16443   arg2 = (Dali::BaseHandle *)jarg2;
16444   if (!arg2) {
16445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16446     return 0;
16447   }
16448   {
16449     try {
16450       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16451     } catch (std::out_of_range& e) {
16452       {
16453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (std::exception& e) {
16456       {
16457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16458       };
16459     } catch (...) {
16460       {
16461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16462       };
16463     }
16464   }
16465   jresult = result;
16466   return jresult;
16467 }
16468
16469
16470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BaseHandle_GetObjectPtr(void * jarg1) {
16471   void * jresult ;
16472   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16473   Dali::RefObject *result = 0 ;
16474
16475   arg1 = (Dali::BaseHandle *)jarg1;
16476   {
16477     try {
16478       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16479     } catch (std::out_of_range& e) {
16480       {
16481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16482       };
16483     } catch (std::exception& e) {
16484       {
16485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16486       };
16487     } catch (...) {
16488       {
16489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16490       };
16491     }
16492   }
16493   jresult = (void *)result;
16494   return jresult;
16495 }
16496
16497
16498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_HasBody(void * jarg1) {
16499   unsigned int jresult ;
16500   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16501   bool result;
16502
16503   arg1 = (Dali::BaseHandle *)jarg1;
16504   {
16505     try {
16506       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16507     } catch (std::out_of_range& e) {
16508       {
16509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16510       };
16511     } catch (std::exception& e) {
16512       {
16513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16514       };
16515     } catch (...) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16518       };
16519     }
16520   }
16521   jresult = result;
16522   return jresult;
16523 }
16524
16525
16526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16527   unsigned int jresult ;
16528   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16529   Dali::BaseHandle *arg2 = 0 ;
16530   bool result;
16531
16532   arg1 = (Dali::BaseHandle *)jarg1;
16533   arg2 = (Dali::BaseHandle *)jarg2;
16534   if (!arg2) {
16535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16536     return 0;
16537   }
16538   {
16539     try {
16540       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16541     } catch (std::out_of_range& e) {
16542       {
16543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (std::exception& e) {
16546       {
16547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16548       };
16549     } catch (...) {
16550       {
16551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16552       };
16553     }
16554   }
16555   jresult = result;
16556   return jresult;
16557 }
16558
16559
16560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16561   unsigned int jresult ;
16562   Dali::BaseHandle *arg1 = 0 ;
16563   Dali::BaseHandle *arg2 = 0 ;
16564   bool result;
16565
16566   arg1 = (Dali::BaseHandle *)jarg1;
16567   if (!arg1) {
16568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16569     return 0;
16570   }
16571   arg2 = (Dali::BaseHandle *)jarg2;
16572   if (!arg2) {
16573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16574     return 0;
16575   }
16576   {
16577     try {
16578       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16579     } catch (std::out_of_range& e) {
16580       {
16581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16582       };
16583     } catch (std::exception& e) {
16584       {
16585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16586       };
16587     } catch (...) {
16588       {
16589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16590       };
16591     }
16592   }
16593   jresult = result;
16594   return jresult;
16595 }
16596
16597
16598 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ConnectionTrackerInterface(void * jarg1) {
16599   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16600
16601   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16602   {
16603     try {
16604       delete arg1;
16605     } catch (std::out_of_range& e) {
16606       {
16607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16608       };
16609     } catch (std::exception& e) {
16610       {
16611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16612       };
16613     } catch (...) {
16614       {
16615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16616       };
16617     }
16618   }
16619 }
16620
16621
16622 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16623   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16624   SlotObserver *arg2 = (SlotObserver *) 0 ;
16625   CallbackBase *arg3 = (CallbackBase *) 0 ;
16626
16627   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16628   arg2 = (SlotObserver *)jarg2;
16629   arg3 = (CallbackBase *)jarg3;
16630   {
16631     try {
16632       (arg1)->SignalConnected(arg2,arg3);
16633     } catch (std::out_of_range& e) {
16634       {
16635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16636       };
16637     } catch (std::exception& e) {
16638       {
16639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16640       };
16641     } catch (...) {
16642       {
16643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16644       };
16645     }
16646   }
16647 }
16648
16649
16650 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SignalObserver(void * jarg1) {
16651   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16652
16653   arg1 = (Dali::SignalObserver *)jarg1;
16654   {
16655     try {
16656       delete arg1;
16657     } catch (std::out_of_range& e) {
16658       {
16659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16660       };
16661     } catch (std::exception& e) {
16662       {
16663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16664       };
16665     } catch (...) {
16666       {
16667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16668       };
16669     }
16670   }
16671 }
16672
16673
16674 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16675   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16676   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16677   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16678
16679   arg1 = (Dali::SignalObserver *)jarg1;
16680   arg2 = (Dali::SlotObserver *)jarg2;
16681   arg3 = (Dali::CallbackBase *)jarg3;
16682   {
16683     try {
16684       (arg1)->SignalDisconnected(arg2,arg3);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16692       };
16693     } catch (...) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16696       };
16697     }
16698   }
16699 }
16700
16701
16702 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SlotObserver(void * jarg1) {
16703   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16704
16705   arg1 = (Dali::SlotObserver *)jarg1;
16706   {
16707     try {
16708       delete arg1;
16709     } catch (std::out_of_range& e) {
16710       {
16711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16712       };
16713     } catch (std::exception& e) {
16714       {
16715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16716       };
16717     } catch (...) {
16718       {
16719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16720       };
16721     }
16722   }
16723 }
16724
16725
16726 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16727   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16728   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16729
16730   arg1 = (Dali::SlotObserver *)jarg1;
16731   arg2 = (Dali::CallbackBase *)jarg2;
16732   {
16733     try {
16734       (arg1)->SlotDisconnected(arg2);
16735     } catch (std::out_of_range& e) {
16736       {
16737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16738       };
16739     } catch (std::exception& e) {
16740       {
16741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16742       };
16743     } catch (...) {
16744       {
16745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16746       };
16747     }
16748   }
16749 }
16750
16751
16752 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ConnectionTracker(void * jarg1) {
16753   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16754
16755   arg1 = (Dali::ConnectionTracker *)jarg1;
16756   {
16757     try {
16758       delete arg1;
16759     } catch (std::out_of_range& e) {
16760       {
16761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16762       };
16763     } catch (std::exception& e) {
16764       {
16765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16766       };
16767     } catch (...) {
16768       {
16769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16770       };
16771     }
16772   }
16773 }
16774
16775
16776 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_DisconnectAll(void * jarg1) {
16777   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16778
16779   arg1 = (Dali::ConnectionTracker *)jarg1;
16780   {
16781     try {
16782       (arg1)->DisconnectAll();
16783     } catch (std::out_of_range& e) {
16784       {
16785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16786       };
16787     } catch (std::exception& e) {
16788       {
16789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16790       };
16791     } catch (...) {
16792       {
16793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16794       };
16795     }
16796   }
16797 }
16798
16799
16800 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16801   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16802   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16803   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16804
16805   arg1 = (Dali::ConnectionTracker *)jarg1;
16806   arg2 = (Dali::SlotObserver *)jarg2;
16807   arg3 = (Dali::CallbackBase *)jarg3;
16808   {
16809     try {
16810       (arg1)->SignalConnected(arg2,arg3);
16811     } catch (std::out_of_range& e) {
16812       {
16813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16814       };
16815     } catch (std::exception& e) {
16816       {
16817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16822       };
16823     }
16824   }
16825 }
16826
16827
16828 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16829   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16830   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16831   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16832
16833   arg1 = (Dali::ConnectionTracker *)jarg1;
16834   arg2 = (Dali::SlotObserver *)jarg2;
16835   arg3 = (Dali::CallbackBase *)jarg3;
16836   {
16837     try {
16838       (arg1)->SignalDisconnected(arg2,arg3);
16839     } catch (std::out_of_range& e) {
16840       {
16841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16842       };
16843     } catch (std::exception& e) {
16844       {
16845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16846       };
16847     } catch (...) {
16848       {
16849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16850       };
16851     }
16852   }
16853 }
16854
16855
16856 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ConnectionTracker_GetConnectionCount(void * jarg1) {
16857   unsigned long jresult ;
16858   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16859   std::size_t result;
16860
16861   arg1 = (Dali::ConnectionTracker *)jarg1;
16862   {
16863     try {
16864       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16865     } catch (std::out_of_range& e) {
16866       {
16867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (std::exception& e) {
16870       {
16871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879   jresult = (unsigned long)result;
16880   return jresult;
16881 }
16882
16883
16884 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectRegistry__SWIG_0() {
16885   void * jresult ;
16886   Dali::ObjectRegistry *result = 0 ;
16887
16888   {
16889     try {
16890       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16891     } catch (std::out_of_range& e) {
16892       {
16893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16894       };
16895     } catch (std::exception& e) {
16896       {
16897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (...) {
16900       {
16901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16902       };
16903     }
16904   }
16905   jresult = (void *)result;
16906   return jresult;
16907 }
16908
16909
16910 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectRegistry(void * jarg1) {
16911   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16912
16913   arg1 = (Dali::ObjectRegistry *)jarg1;
16914   {
16915     try {
16916       delete arg1;
16917     } catch (std::out_of_range& e) {
16918       {
16919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16920       };
16921     } catch (std::exception& e) {
16922       {
16923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16924       };
16925     } catch (...) {
16926       {
16927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16928       };
16929     }
16930   }
16931 }
16932
16933
16934 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectRegistry__SWIG_1(void * jarg1) {
16935   void * jresult ;
16936   Dali::ObjectRegistry *arg1 = 0 ;
16937   Dali::ObjectRegistry *result = 0 ;
16938
16939   arg1 = (Dali::ObjectRegistry *)jarg1;
16940   if (!arg1) {
16941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16942     return 0;
16943   }
16944   {
16945     try {
16946       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16947     } catch (std::out_of_range& e) {
16948       {
16949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16950       };
16951     } catch (std::exception& e) {
16952       {
16953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16954       };
16955     } catch (...) {
16956       {
16957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16958       };
16959     }
16960   }
16961   jresult = (void *)result;
16962   return jresult;
16963 }
16964
16965
16966 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16967   void * jresult ;
16968   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16969   Dali::ObjectRegistry *arg2 = 0 ;
16970   Dali::ObjectRegistry *result = 0 ;
16971
16972   arg1 = (Dali::ObjectRegistry *)jarg1;
16973   arg2 = (Dali::ObjectRegistry *)jarg2;
16974   if (!arg2) {
16975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16976     return 0;
16977   }
16978   {
16979     try {
16980       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16981     } catch (std::out_of_range& e) {
16982       {
16983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16984       };
16985     } catch (std::exception& e) {
16986       {
16987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16988       };
16989     } catch (...) {
16990       {
16991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16992       };
16993     }
16994   }
16995   jresult = (void *)result;
16996   return jresult;
16997 }
16998
16999
17000 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17001   void * jresult ;
17002   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17003   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17004
17005   arg1 = (Dali::ObjectRegistry *)jarg1;
17006   {
17007     try {
17008       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (...) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17020       };
17021     }
17022   }
17023   jresult = (void *)result;
17024   return jresult;
17025 }
17026
17027
17028 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17029   void * jresult ;
17030   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17031   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17032
17033   arg1 = (Dali::ObjectRegistry *)jarg1;
17034   {
17035     try {
17036       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17037     } catch (std::out_of_range& e) {
17038       {
17039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17040       };
17041     } catch (std::exception& e) {
17042       {
17043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17044       };
17045     } catch (...) {
17046       {
17047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17048       };
17049     }
17050   }
17051   jresult = (void *)result;
17052   return jresult;
17053 }
17054
17055
17056 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyCondition__SWIG_0() {
17057   void * jresult ;
17058   Dali::PropertyCondition *result = 0 ;
17059
17060   {
17061     try {
17062       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17063     } catch (std::out_of_range& e) {
17064       {
17065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17066       };
17067     } catch (std::exception& e) {
17068       {
17069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (...) {
17072       {
17073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17074       };
17075     }
17076   }
17077   jresult = (void *)result;
17078   return jresult;
17079 }
17080
17081
17082 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyCondition(void * jarg1) {
17083   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17084
17085   arg1 = (Dali::PropertyCondition *)jarg1;
17086   {
17087     try {
17088       delete arg1;
17089     } catch (std::out_of_range& e) {
17090       {
17091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17092       };
17093     } catch (std::exception& e) {
17094       {
17095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17096       };
17097     } catch (...) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17100       };
17101     }
17102   }
17103 }
17104
17105
17106 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyCondition__SWIG_1(void * jarg1) {
17107   void * jresult ;
17108   Dali::PropertyCondition *arg1 = 0 ;
17109   Dali::PropertyCondition *result = 0 ;
17110
17111   arg1 = (Dali::PropertyCondition *)jarg1;
17112   if (!arg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17114     return 0;
17115   }
17116   {
17117     try {
17118       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (...) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17130       };
17131     }
17132   }
17133   jresult = (void *)result;
17134   return jresult;
17135 }
17136
17137
17138 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17139   void * jresult ;
17140   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17141   Dali::PropertyCondition *arg2 = 0 ;
17142   Dali::PropertyCondition *result = 0 ;
17143
17144   arg1 = (Dali::PropertyCondition *)jarg1;
17145   arg2 = (Dali::PropertyCondition *)jarg2;
17146   if (!arg2) {
17147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17148     return 0;
17149   }
17150   {
17151     try {
17152       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17153     } catch (std::out_of_range& e) {
17154       {
17155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17156       };
17157     } catch (std::exception& e) {
17158       {
17159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17160       };
17161     } catch (...) {
17162       {
17163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17164       };
17165     }
17166   }
17167   jresult = (void *)result;
17168   return jresult;
17169 }
17170
17171
17172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyCondition_GetArgumentCount(void * jarg1) {
17173   unsigned long jresult ;
17174   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17175   std::size_t result;
17176
17177   arg1 = (Dali::PropertyCondition *)jarg1;
17178   {
17179     try {
17180       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17181     } catch (std::out_of_range& e) {
17182       {
17183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17184       };
17185     } catch (std::exception& e) {
17186       {
17187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (...) {
17190       {
17191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17192       };
17193     }
17194   }
17195   jresult = (unsigned long)result;
17196   return jresult;
17197 }
17198
17199
17200 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17201   float jresult ;
17202   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17203   std::size_t arg2 ;
17204   float result;
17205
17206   arg1 = (Dali::PropertyCondition *)jarg1;
17207   arg2 = (std::size_t)jarg2;
17208   {
17209     try {
17210       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17211     } catch (std::out_of_range& e) {
17212       {
17213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17214       };
17215     } catch (std::exception& e) {
17216       {
17217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (...) {
17220       {
17221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17222       };
17223     }
17224   }
17225   jresult = result;
17226   return jresult;
17227 }
17228
17229
17230 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LessThanCondition(float jarg1) {
17231   void * jresult ;
17232   float arg1 ;
17233   Dali::PropertyCondition result;
17234
17235   arg1 = (float)jarg1;
17236   {
17237     try {
17238       result = Dali::LessThanCondition(arg1);
17239     } catch (std::out_of_range& e) {
17240       {
17241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17242       };
17243     } catch (std::exception& e) {
17244       {
17245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17246       };
17247     } catch (...) {
17248       {
17249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17250       };
17251     }
17252   }
17253   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17254   return jresult;
17255 }
17256
17257
17258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GreaterThanCondition(float jarg1) {
17259   void * jresult ;
17260   float arg1 ;
17261   Dali::PropertyCondition result;
17262
17263   arg1 = (float)jarg1;
17264   {
17265     try {
17266       result = Dali::GreaterThanCondition(arg1);
17267     } catch (std::out_of_range& e) {
17268       {
17269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (std::exception& e) {
17272       {
17273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17282   return jresult;
17283 }
17284
17285
17286 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_InsideCondition(float jarg1, float jarg2) {
17287   void * jresult ;
17288   float arg1 ;
17289   float arg2 ;
17290   Dali::PropertyCondition result;
17291
17292   arg1 = (float)jarg1;
17293   arg2 = (float)jarg2;
17294   {
17295     try {
17296       result = Dali::InsideCondition(arg1,arg2);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (...) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17308       };
17309     }
17310   }
17311   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17312   return jresult;
17313 }
17314
17315
17316 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_OutsideCondition(float jarg1, float jarg2) {
17317   void * jresult ;
17318   float arg1 ;
17319   float arg2 ;
17320   Dali::PropertyCondition result;
17321
17322   arg1 = (float)jarg1;
17323   arg2 = (float)jarg2;
17324   {
17325     try {
17326       result = Dali::OutsideCondition(arg1,arg2);
17327     } catch (std::out_of_range& e) {
17328       {
17329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (std::exception& e) {
17332       {
17333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StepCondition__SWIG_0(float jarg1, float jarg2) {
17347   void * jresult ;
17348   float arg1 ;
17349   float arg2 ;
17350   Dali::PropertyCondition result;
17351
17352   arg1 = (float)jarg1;
17353   arg2 = (float)jarg2;
17354   {
17355     try {
17356       result = Dali::StepCondition(arg1,arg2);
17357     } catch (std::out_of_range& e) {
17358       {
17359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17360       };
17361     } catch (std::exception& e) {
17362       {
17363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (...) {
17366       {
17367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17368       };
17369     }
17370   }
17371   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17372   return jresult;
17373 }
17374
17375
17376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StepCondition__SWIG_1(float jarg1) {
17377   void * jresult ;
17378   float arg1 ;
17379   Dali::PropertyCondition result;
17380
17381   arg1 = (float)jarg1;
17382   {
17383     try {
17384       result = Dali::StepCondition(arg1);
17385     } catch (std::out_of_range& e) {
17386       {
17387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17388       };
17389     } catch (std::exception& e) {
17390       {
17391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17392       };
17393     } catch (...) {
17394       {
17395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17396       };
17397     }
17398   }
17399   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17400   return jresult;
17401 }
17402
17403
17404 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VariableStepCondition(void * jarg1) {
17405   void * jresult ;
17406   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17407   Dali::PropertyCondition result;
17408
17409   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17410   if (!arg1) {
17411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17412     return 0;
17413   }
17414   {
17415     try {
17416       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17417     } catch (std::out_of_range& e) {
17418       {
17419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17420       };
17421     } catch (std::exception& e) {
17422       {
17423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17424       };
17425     } catch (...) {
17426       {
17427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17428       };
17429     }
17430   }
17431   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17432   return jresult;
17433 }
17434
17435
17436 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotification__SWIG_0() {
17437   void * jresult ;
17438   Dali::PropertyNotification *result = 0 ;
17439
17440   {
17441     try {
17442       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17443     } catch (std::out_of_range& e) {
17444       {
17445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17446       };
17447     } catch (std::exception& e) {
17448       {
17449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17450       };
17451     } catch (...) {
17452       {
17453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17454       };
17455     }
17456   }
17457   jresult = (void *)result;
17458   return jresult;
17459 }
17460
17461
17462 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_DownCast(void * jarg1) {
17463   void * jresult ;
17464   Dali::BaseHandle arg1 ;
17465   Dali::BaseHandle *argp1 ;
17466   Dali::PropertyNotification result;
17467
17468   argp1 = (Dali::BaseHandle *)jarg1;
17469   if (!argp1) {
17470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17471     return 0;
17472   }
17473   arg1 = *argp1;
17474   {
17475     try {
17476       result = Dali::PropertyNotification::DownCast(arg1);
17477     } catch (std::out_of_range& e) {
17478       {
17479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17480       };
17481     } catch (std::exception& e) {
17482       {
17483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17484       };
17485     } catch (...) {
17486       {
17487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17488       };
17489     }
17490   }
17491   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyNotification(void * jarg1) {
17497   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17498
17499   arg1 = (Dali::PropertyNotification *)jarg1;
17500   {
17501     try {
17502       delete arg1;
17503     } catch (std::out_of_range& e) {
17504       {
17505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17506       };
17507     } catch (std::exception& e) {
17508       {
17509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17510       };
17511     } catch (...) {
17512       {
17513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17514       };
17515     }
17516   }
17517 }
17518
17519
17520 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotification__SWIG_1(void * jarg1) {
17521   void * jresult ;
17522   Dali::PropertyNotification *arg1 = 0 ;
17523   Dali::PropertyNotification *result = 0 ;
17524
17525   arg1 = (Dali::PropertyNotification *)jarg1;
17526   if (!arg1) {
17527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17528     return 0;
17529   }
17530   {
17531     try {
17532       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17533     } catch (std::out_of_range& e) {
17534       {
17535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17536       };
17537     } catch (std::exception& e) {
17538       {
17539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17544       };
17545     }
17546   }
17547   jresult = (void *)result;
17548   return jresult;
17549 }
17550
17551
17552 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17553   void * jresult ;
17554   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17555   Dali::PropertyNotification *arg2 = 0 ;
17556   Dali::PropertyNotification *result = 0 ;
17557
17558   arg1 = (Dali::PropertyNotification *)jarg1;
17559   arg2 = (Dali::PropertyNotification *)jarg2;
17560   if (!arg2) {
17561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17562     return 0;
17563   }
17564   {
17565     try {
17566       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17567     } catch (std::out_of_range& e) {
17568       {
17569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (std::exception& e) {
17572       {
17573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17574       };
17575     } catch (...) {
17576       {
17577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17578       };
17579     }
17580   }
17581   jresult = (void *)result;
17582   return jresult;
17583 }
17584
17585
17586 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17587   void * jresult ;
17588   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17589   Dali::PropertyCondition result;
17590
17591   arg1 = (Dali::PropertyNotification *)jarg1;
17592   {
17593     try {
17594       result = (arg1)->GetCondition();
17595     } catch (std::out_of_range& e) {
17596       {
17597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17598       };
17599     } catch (std::exception& e) {
17600       {
17601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17602       };
17603     } catch (...) {
17604       {
17605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17606       };
17607     }
17608   }
17609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17610   return jresult;
17611 }
17612
17613
17614 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_GetTarget(void * jarg1) {
17615   void * jresult ;
17616   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17617   Dali::Handle result;
17618
17619   arg1 = (Dali::PropertyNotification *)jarg1;
17620   {
17621     try {
17622       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (...) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17634       };
17635     }
17636   }
17637   jresult = new Dali::Handle((const Dali::Handle &)result);
17638   return jresult;
17639 }
17640
17641
17642 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetTargetProperty(void * jarg1) {
17643   int jresult ;
17644   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17645   Dali::Property::Index result;
17646
17647   arg1 = (Dali::PropertyNotification *)jarg1;
17648   {
17649     try {
17650       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17651     } catch (std::out_of_range& e) {
17652       {
17653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17654       };
17655     } catch (std::exception& e) {
17656       {
17657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17658       };
17659     } catch (...) {
17660       {
17661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17662       };
17663     }
17664   }
17665   jresult = result;
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17671   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17672   Dali::PropertyNotification::NotifyMode arg2 ;
17673
17674   arg1 = (Dali::PropertyNotification *)jarg1;
17675   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17676   {
17677     try {
17678       (arg1)->SetNotifyMode(arg2);
17679     } catch (std::out_of_range& e) {
17680       {
17681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17682       };
17683     } catch (std::exception& e) {
17684       {
17685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17686       };
17687     } catch (...) {
17688       {
17689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17690       };
17691     }
17692   }
17693 }
17694
17695
17696 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetNotifyMode(void * jarg1) {
17697   int jresult ;
17698   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17699   Dali::PropertyNotification::NotifyMode result;
17700
17701   arg1 = (Dali::PropertyNotification *)jarg1;
17702   {
17703     try {
17704       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17705     } catch (std::out_of_range& e) {
17706       {
17707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (std::exception& e) {
17710       {
17711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17712       };
17713     } catch (...) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17716       };
17717     }
17718   }
17719   jresult = (int)result;
17720   return jresult;
17721 }
17722
17723
17724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PropertyNotification_GetNotifyResult(void * jarg1) {
17725   unsigned int jresult ;
17726   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17727   bool result;
17728
17729   arg1 = (Dali::PropertyNotification *)jarg1;
17730   {
17731     try {
17732       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17733     } catch (std::out_of_range& e) {
17734       {
17735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17736       };
17737     } catch (std::exception& e) {
17738       {
17739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (...) {
17742       {
17743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17744       };
17745     }
17746   }
17747   jresult = result;
17748   return jresult;
17749 }
17750
17751
17752 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyNotification_NotifySignal(void * jarg1) {
17753   void * jresult ;
17754   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17755   Dali::PropertyNotifySignalType *result = 0 ;
17756
17757   arg1 = (Dali::PropertyNotification *)jarg1;
17758   {
17759     try {
17760       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17761     } catch (std::out_of_range& e) {
17762       {
17763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (std::exception& e) {
17766       {
17767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (...) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17772       };
17773     }
17774   }
17775   jresult = (void *)result;
17776   return jresult;
17777 }
17778
17779
17780 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Handle__SWIG_0() {
17781   void * jresult ;
17782   Dali::Handle *result = 0 ;
17783
17784   {
17785     try {
17786       result = (Dali::Handle *)new Dali::Handle();
17787     } catch (std::out_of_range& e) {
17788       {
17789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17790       };
17791     } catch (std::exception& e) {
17792       {
17793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17794       };
17795     } catch (...) {
17796       {
17797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17798       };
17799     }
17800   }
17801   jresult = (void *)result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_New() {
17807   void * jresult ;
17808   Dali::Handle result;
17809
17810   {
17811     try {
17812       result = Dali::Handle::New();
17813     } catch (std::out_of_range& e) {
17814       {
17815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17816       };
17817     } catch (std::exception& e) {
17818       {
17819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (...) {
17822       {
17823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17824       };
17825     }
17826   }
17827   jresult = new Dali::Handle((const Dali::Handle &)result);
17828   return jresult;
17829 }
17830
17831
17832 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Handle(void * jarg1) {
17833   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17834
17835   arg1 = (Dali::Handle *)jarg1;
17836   {
17837     try {
17838       delete arg1;
17839     } catch (std::out_of_range& e) {
17840       {
17841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17842       };
17843     } catch (std::exception& e) {
17844       {
17845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17846       };
17847     } catch (...) {
17848       {
17849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17850       };
17851     }
17852   }
17853 }
17854
17855
17856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Handle__SWIG_1(void * jarg1) {
17857   void * jresult ;
17858   Dali::Handle *arg1 = 0 ;
17859   Dali::Handle *result = 0 ;
17860
17861   arg1 = (Dali::Handle *)jarg1;
17862   if (!arg1) {
17863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17864     return 0;
17865   }
17866   {
17867     try {
17868       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17869     } catch (std::out_of_range& e) {
17870       {
17871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (std::exception& e) {
17874       {
17875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17880       };
17881     }
17882   }
17883   jresult = (void *)result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_Assign(void * jarg1, void * jarg2) {
17889   void * jresult ;
17890   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17891   Dali::Handle *arg2 = 0 ;
17892   Dali::Handle *result = 0 ;
17893
17894   arg1 = (Dali::Handle *)jarg1;
17895   arg2 = (Dali::Handle *)jarg2;
17896   if (!arg2) {
17897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17898     return 0;
17899   }
17900   {
17901     try {
17902       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17903     } catch (std::out_of_range& e) {
17904       {
17905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (std::exception& e) {
17908       {
17909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17910       };
17911     } catch (...) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17914       };
17915     }
17916   }
17917   jresult = (void *)result;
17918   return jresult;
17919 }
17920
17921
17922 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_DownCast(void * jarg1) {
17923   void * jresult ;
17924   Dali::BaseHandle arg1 ;
17925   Dali::BaseHandle *argp1 ;
17926   Dali::Handle result;
17927
17928   argp1 = (Dali::BaseHandle *)jarg1;
17929   if (!argp1) {
17930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17931     return 0;
17932   }
17933   arg1 = *argp1;
17934   {
17935     try {
17936       result = Dali::Handle::DownCast(arg1);
17937     } catch (std::out_of_range& e) {
17938       {
17939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (std::exception& e) {
17942       {
17943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (...) {
17946       {
17947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17948       };
17949     }
17950   }
17951   jresult = new Dali::Handle((const Dali::Handle &)result);
17952   return jresult;
17953 }
17954
17955
17956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_Supports(void * jarg1, int jarg2) {
17957   unsigned int jresult ;
17958   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17959   Dali::Handle::Capability arg2 ;
17960   bool result;
17961
17962   arg1 = (Dali::Handle *)jarg1;
17963   arg2 = (Dali::Handle::Capability)jarg2;
17964   {
17965     try {
17966       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (...) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17978       };
17979     }
17980   }
17981   jresult = result;
17982   return jresult;
17983 }
17984
17985
17986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyCount(void * jarg1) {
17987   unsigned int jresult ;
17988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17989   unsigned int result;
17990
17991   arg1 = (Dali::Handle *)jarg1;
17992   {
17993     try {
17994       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17995     } catch (std::out_of_range& e) {
17996       {
17997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17998       };
17999     } catch (std::exception& e) {
18000       {
18001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18002       };
18003     } catch (...) {
18004       {
18005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18006       };
18007     }
18008   }
18009   jresult = result;
18010   return jresult;
18011 }
18012
18013
18014 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Handle_GetPropertyName(void * jarg1, int jarg2) {
18015   char * jresult ;
18016   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18017   Dali::Property::Index arg2 ;
18018   std::string result;
18019
18020   arg1 = (Dali::Handle *)jarg1;
18021   arg2 = (Dali::Property::Index)jarg2;
18022   {
18023     try {
18024       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18025     } catch (std::out_of_range& e) {
18026       {
18027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18028       };
18029     } catch (std::exception& e) {
18030       {
18031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18032       };
18033     } catch (...) {
18034       {
18035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18036       };
18037     }
18038   }
18039   jresult = SWIG_csharp_string_callback((&result)->c_str());
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18045   int jresult ;
18046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18047   std::string *arg2 = 0 ;
18048   Dali::Property::Index result;
18049
18050   arg1 = (Dali::Handle *)jarg1;
18051   if (!jarg2) {
18052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18053     return 0;
18054   }
18055   std::string arg2_str(jarg2);
18056   arg2 = &arg2_str;
18057   {
18058     try {
18059       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18060     } catch (std::out_of_range& e) {
18061       {
18062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18063       };
18064     } catch (std::exception& e) {
18065       {
18066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18067       };
18068     } catch (...) {
18069       {
18070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18071       };
18072     }
18073   }
18074   jresult = result;
18075
18076   //argout typemap for const std::string&
18077
18078   return jresult;
18079 }
18080
18081
18082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18083   unsigned int jresult ;
18084   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18085   Dali::Property::Index arg2 ;
18086   bool result;
18087
18088   arg1 = (Dali::Handle *)jarg1;
18089   arg2 = (Dali::Property::Index)jarg2;
18090   {
18091     try {
18092       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18093     } catch (std::out_of_range& e) {
18094       {
18095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18096       };
18097     } catch (std::exception& e) {
18098       {
18099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18100       };
18101     } catch (...) {
18102       {
18103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18104       };
18105     }
18106   }
18107   jresult = result;
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18113   unsigned int jresult ;
18114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18115   Dali::Property::Index arg2 ;
18116   bool result;
18117
18118   arg1 = (Dali::Handle *)jarg1;
18119   arg2 = (Dali::Property::Index)jarg2;
18120   {
18121     try {
18122       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18123     } catch (std::out_of_range& e) {
18124       {
18125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (std::exception& e) {
18128       {
18129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137   jresult = result;
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18143   unsigned int jresult ;
18144   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18145   Dali::Property::Index arg2 ;
18146   bool result;
18147
18148   arg1 = (Dali::Handle *)jarg1;
18149   arg2 = (Dali::Property::Index)jarg2;
18150   {
18151     try {
18152       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18153     } catch (std::out_of_range& e) {
18154       {
18155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18156       };
18157     } catch (std::exception& e) {
18158       {
18159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (...) {
18162       {
18163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18164       };
18165     }
18166   }
18167   jresult = result;
18168   return jresult;
18169 }
18170
18171
18172 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_GetPropertyType(void * jarg1, int jarg2) {
18173   int jresult ;
18174   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18175   Dali::Property::Index arg2 ;
18176   Dali::Property::Type result;
18177
18178   arg1 = (Dali::Handle *)jarg1;
18179   arg2 = (Dali::Property::Index)jarg2;
18180   {
18181     try {
18182       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18183     } catch (std::out_of_range& e) {
18184       {
18185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (std::exception& e) {
18188       {
18189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197   jresult = (int)result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18203   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18204   Dali::Property::Index arg2 ;
18205   Dali::Property::Value *arg3 = 0 ;
18206
18207   arg1 = (Dali::Handle *)jarg1;
18208   arg2 = (Dali::Property::Index)jarg2;
18209   arg3 = (Dali::Property::Value *)jarg3;
18210   if (!arg3) {
18211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18212     return ;
18213   }
18214   {
18215     try {
18216       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18217     } catch (std::out_of_range& e) {
18218       {
18219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18220       };
18221     } catch (std::exception& e) {
18222       {
18223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18224       };
18225     } catch (...) {
18226       {
18227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18228       };
18229     }
18230   }
18231 }
18232
18233
18234 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18235   int jresult ;
18236   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18237   std::string *arg2 = 0 ;
18238   Dali::Property::Value *arg3 = 0 ;
18239   Dali::Property::Index result;
18240
18241   arg1 = (Dali::Handle *)jarg1;
18242   if (!jarg2) {
18243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18244     return 0;
18245   }
18246   std::string arg2_str(jarg2);
18247   arg2 = &arg2_str;
18248   arg3 = (Dali::Property::Value *)jarg3;
18249   if (!arg3) {
18250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18251     return 0;
18252   }
18253   {
18254     try {
18255       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18256     } catch (std::out_of_range& e) {
18257       {
18258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18259       };
18260     } catch (std::exception& e) {
18261       {
18262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18263       };
18264     } catch (...) {
18265       {
18266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18267       };
18268     }
18269   }
18270   jresult = result;
18271
18272   //argout typemap for const std::string&
18273
18274   return jresult;
18275 }
18276
18277
18278 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18279   int jresult ;
18280   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18281   std::string *arg2 = 0 ;
18282   Dali::Property::Value *arg3 = 0 ;
18283   Dali::Property::AccessMode arg4 ;
18284   Dali::Property::Index result;
18285
18286   arg1 = (Dali::Handle *)jarg1;
18287   if (!jarg2) {
18288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18289     return 0;
18290   }
18291   std::string arg2_str(jarg2);
18292   arg2 = &arg2_str;
18293   arg3 = (Dali::Property::Value *)jarg3;
18294   if (!arg3) {
18295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18296     return 0;
18297   }
18298   arg4 = (Dali::Property::AccessMode)jarg4;
18299   {
18300     try {
18301       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18302     } catch (std::out_of_range& e) {
18303       {
18304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18305       };
18306     } catch (std::exception& e) {
18307       {
18308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (...) {
18311       {
18312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18313       };
18314     }
18315   }
18316   jresult = result;
18317
18318   //argout typemap for const std::string&
18319
18320   return jresult;
18321 }
18322
18323
18324 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_GetProperty(void * jarg1, int jarg2) {
18325   void * jresult ;
18326   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18327   Dali::Property::Index arg2 ;
18328   Dali::Property::Value result;
18329
18330   arg1 = (Dali::Handle *)jarg1;
18331   arg2 = (Dali::Property::Index)jarg2;
18332   {
18333     try {
18334       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18335     } catch (std::out_of_range& e) {
18336       {
18337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (std::exception& e) {
18340       {
18341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18342       };
18343     } catch (...) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18346       };
18347     }
18348   }
18349   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18350   return jresult;
18351 }
18352
18353
18354 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18356   Dali::Property::IndexContainer *arg2 = 0 ;
18357
18358   arg1 = (Dali::Handle *)jarg1;
18359   arg2 = (Dali::Property::IndexContainer *)jarg2;
18360   if (!arg2) {
18361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18362     return ;
18363   }
18364   {
18365     try {
18366       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18367     } catch (std::out_of_range& e) {
18368       {
18369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18370       };
18371     } catch (std::exception& e) {
18372       {
18373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18374       };
18375     } catch (...) {
18376       {
18377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18378       };
18379     }
18380   }
18381 }
18382
18383
18384 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18385   void * jresult ;
18386   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18387   Dali::Property::Index arg2 ;
18388   Dali::PropertyCondition *arg3 = 0 ;
18389   Dali::PropertyNotification result;
18390
18391   arg1 = (Dali::Handle *)jarg1;
18392   arg2 = (Dali::Property::Index)jarg2;
18393   arg3 = (Dali::PropertyCondition *)jarg3;
18394   if (!arg3) {
18395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18396     return 0;
18397   }
18398   {
18399     try {
18400       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18401     } catch (std::out_of_range& e) {
18402       {
18403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18404       };
18405     } catch (std::exception& e) {
18406       {
18407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18408       };
18409     } catch (...) {
18410       {
18411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18412       };
18413     }
18414   }
18415   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18416   return jresult;
18417 }
18418
18419
18420 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18421   void * jresult ;
18422   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18423   Dali::Property::Index arg2 ;
18424   int arg3 ;
18425   Dali::PropertyCondition *arg4 = 0 ;
18426   Dali::PropertyNotification result;
18427
18428   arg1 = (Dali::Handle *)jarg1;
18429   arg2 = (Dali::Property::Index)jarg2;
18430   arg3 = (int)jarg3;
18431   arg4 = (Dali::PropertyCondition *)jarg4;
18432   if (!arg4) {
18433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18434     return 0;
18435   }
18436   {
18437     try {
18438       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18439     } catch (std::out_of_range& e) {
18440       {
18441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18442       };
18443     } catch (std::exception& e) {
18444       {
18445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18446       };
18447     } catch (...) {
18448       {
18449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18450       };
18451     }
18452   }
18453   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18454   return jresult;
18455 }
18456
18457
18458 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18459   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18460   Dali::PropertyNotification arg2 ;
18461   Dali::PropertyNotification *argp2 ;
18462
18463   arg1 = (Dali::Handle *)jarg1;
18464   argp2 = (Dali::PropertyNotification *)jarg2;
18465   if (!argp2) {
18466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18467     return ;
18468   }
18469   arg2 = *argp2;
18470   {
18471     try {
18472       (arg1)->RemovePropertyNotification(arg2);
18473     } catch (std::out_of_range& e) {
18474       {
18475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18476       };
18477     } catch (std::exception& e) {
18478       {
18479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18480       };
18481     } catch (...) {
18482       {
18483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18484       };
18485     }
18486   }
18487 }
18488
18489
18490 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemovePropertyNotifications(void * jarg1) {
18491   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18492
18493   arg1 = (Dali::Handle *)jarg1;
18494   {
18495     try {
18496       (arg1)->RemovePropertyNotifications();
18497     } catch (std::out_of_range& e) {
18498       {
18499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18500       };
18501     } catch (std::exception& e) {
18502       {
18503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18508       };
18509     }
18510   }
18511 }
18512
18513
18514 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18515   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18516
18517   arg1 = (Dali::Handle *)jarg1;
18518   {
18519     try {
18520       (arg1)->RemoveConstraints();
18521     } catch (std::out_of_range& e) {
18522       {
18523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18524       };
18525     } catch (std::exception& e) {
18526       {
18527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18528       };
18529     } catch (...) {
18530       {
18531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18532       };
18533     }
18534   }
18535 }
18536
18537
18538 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18539   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18540   unsigned int arg2 ;
18541
18542   arg1 = (Dali::Handle *)jarg1;
18543   arg2 = (unsigned int)jarg2;
18544   {
18545     try {
18546       (arg1)->RemoveConstraints(arg2);
18547     } catch (std::out_of_range& e) {
18548       {
18549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18550       };
18551     } catch (std::exception& e) {
18552       {
18553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18554       };
18555     } catch (...) {
18556       {
18557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18558       };
18559     }
18560   }
18561 }
18562
18563
18564 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WEIGHT_get() {
18565   int jresult ;
18566   Dali::Property::Index result;
18567
18568   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18569   jresult = result;
18570   return jresult;
18571 }
18572
18573
18574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_New() {
18575   void * jresult ;
18576   Dali::Handle result;
18577
18578   {
18579     try {
18580       result = Dali::WeightObject::New();
18581     } catch (std::out_of_range& e) {
18582       {
18583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18584       };
18585     } catch (std::exception& e) {
18586       {
18587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18588       };
18589     } catch (...) {
18590       {
18591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18592       };
18593     }
18594   }
18595   jresult = new Dali::Handle((const Dali::Handle &)result);
18596   return jresult;
18597 }
18598
18599
18600 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeInfo__SWIG_0() {
18601   void * jresult ;
18602   Dali::TypeInfo *result = 0 ;
18603
18604   {
18605     try {
18606       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18607     } catch (std::out_of_range& e) {
18608       {
18609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18610       };
18611     } catch (std::exception& e) {
18612       {
18613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18614       };
18615     } catch (...) {
18616       {
18617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18618       };
18619     }
18620   }
18621   jresult = (void *)result;
18622   return jresult;
18623 }
18624
18625
18626 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeInfo(void * jarg1) {
18627   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18628
18629   arg1 = (Dali::TypeInfo *)jarg1;
18630   {
18631     try {
18632       delete arg1;
18633     } catch (std::out_of_range& e) {
18634       {
18635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18636       };
18637     } catch (std::exception& e) {
18638       {
18639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18640       };
18641     } catch (...) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18644       };
18645     }
18646   }
18647 }
18648
18649
18650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeInfo__SWIG_1(void * jarg1) {
18651   void * jresult ;
18652   Dali::TypeInfo *arg1 = 0 ;
18653   Dali::TypeInfo *result = 0 ;
18654
18655   arg1 = (Dali::TypeInfo *)jarg1;
18656   if (!arg1) {
18657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18658     return 0;
18659   }
18660   {
18661     try {
18662       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18663     } catch (std::out_of_range& e) {
18664       {
18665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18666       };
18667     } catch (std::exception& e) {
18668       {
18669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18670       };
18671     } catch (...) {
18672       {
18673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18674       };
18675     }
18676   }
18677   jresult = (void *)result;
18678   return jresult;
18679 }
18680
18681
18682 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_Assign(void * jarg1, void * jarg2) {
18683   void * jresult ;
18684   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18685   Dali::TypeInfo *arg2 = 0 ;
18686   Dali::TypeInfo *result = 0 ;
18687
18688   arg1 = (Dali::TypeInfo *)jarg1;
18689   arg2 = (Dali::TypeInfo *)jarg2;
18690   if (!arg2) {
18691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18692     return 0;
18693   }
18694   {
18695     try {
18696       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18697     } catch (std::out_of_range& e) {
18698       {
18699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18700       };
18701     } catch (std::exception& e) {
18702       {
18703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18704       };
18705     } catch (...) {
18706       {
18707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18708       };
18709     }
18710   }
18711   jresult = (void *)result;
18712   return jresult;
18713 }
18714
18715
18716 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetName(void * jarg1) {
18717   char * jresult ;
18718   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18719   std::string *result = 0 ;
18720
18721   arg1 = (Dali::TypeInfo *)jarg1;
18722   {
18723     try {
18724       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18725     } catch (std::out_of_range& e) {
18726       {
18727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18728       };
18729     } catch (std::exception& e) {
18730       {
18731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (...) {
18734       {
18735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18736       };
18737     }
18738   }
18739   jresult = SWIG_csharp_string_callback(result->c_str());
18740   return jresult;
18741 }
18742
18743
18744 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetBaseName(void * jarg1) {
18745   char * jresult ;
18746   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18747   std::string *result = 0 ;
18748
18749   arg1 = (Dali::TypeInfo *)jarg1;
18750   {
18751     try {
18752       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18753     } catch (std::out_of_range& e) {
18754       {
18755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18756       };
18757     } catch (std::exception& e) {
18758       {
18759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18760       };
18761     } catch (...) {
18762       {
18763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18764       };
18765     }
18766   }
18767   jresult = SWIG_csharp_string_callback(result->c_str());
18768   return jresult;
18769 }
18770
18771
18772 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_CreateInstance(void * jarg1) {
18773   void * jresult ;
18774   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18775   Dali::BaseHandle result;
18776
18777   arg1 = (Dali::TypeInfo *)jarg1;
18778   {
18779     try {
18780       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18781     } catch (std::out_of_range& e) {
18782       {
18783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (std::exception& e) {
18786       {
18787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeInfo_GetCreator(void * jarg1) {
18801   void * jresult ;
18802   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18803   Dali::TypeInfo::CreateFunction result;
18804
18805   arg1 = (Dali::TypeInfo *)jarg1;
18806   {
18807     try {
18808       result = (Dali::TypeInfo::CreateFunction)((Dali::TypeInfo const *)arg1)->GetCreator();
18809     } catch (std::out_of_range& e) {
18810       {
18811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18812       };
18813     } catch (std::exception& e) {
18814       {
18815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (...) {
18818       {
18819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18820       };
18821     }
18822   }
18823   jresult = (void *)result;
18824   return jresult;
18825 }
18826
18827
18828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetActionCount(void * jarg1) {
18829   unsigned long jresult ;
18830   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18831   size_t result;
18832
18833   arg1 = (Dali::TypeInfo *)jarg1;
18834   {
18835     try {
18836       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18837     } catch (std::out_of_range& e) {
18838       {
18839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18840       };
18841     } catch (std::exception& e) {
18842       {
18843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18844       };
18845     } catch (...) {
18846       {
18847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18848       };
18849     }
18850   }
18851   jresult = (unsigned long)result;
18852   return jresult;
18853 }
18854
18855
18856 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18857   char * jresult ;
18858   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18859   size_t arg2 ;
18860   std::string result;
18861
18862   arg1 = (Dali::TypeInfo *)jarg1;
18863   arg2 = (size_t)jarg2;
18864   {
18865     try {
18866       result = (arg1)->GetActionName(arg2);
18867     } catch (std::out_of_range& e) {
18868       {
18869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18870       };
18871     } catch (std::exception& e) {
18872       {
18873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18874       };
18875     } catch (...) {
18876       {
18877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18878       };
18879     }
18880   }
18881   jresult = SWIG_csharp_string_callback((&result)->c_str());
18882   return jresult;
18883 }
18884
18885
18886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetSignalCount(void * jarg1) {
18887   unsigned long jresult ;
18888   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18889   size_t result;
18890
18891   arg1 = (Dali::TypeInfo *)jarg1;
18892   {
18893     try {
18894       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18895     } catch (std::out_of_range& e) {
18896       {
18897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18898       };
18899     } catch (std::exception& e) {
18900       {
18901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18902       };
18903     } catch (...) {
18904       {
18905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18906       };
18907     }
18908   }
18909   jresult = (unsigned long)result;
18910   return jresult;
18911 }
18912
18913
18914 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18915   char * jresult ;
18916   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18917   size_t arg2 ;
18918   std::string result;
18919
18920   arg1 = (Dali::TypeInfo *)jarg1;
18921   arg2 = (size_t)jarg2;
18922   {
18923     try {
18924       result = (arg1)->GetSignalName(arg2);
18925     } catch (std::out_of_range& e) {
18926       {
18927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18928       };
18929     } catch (std::exception& e) {
18930       {
18931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18932       };
18933     } catch (...) {
18934       {
18935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18936       };
18937     }
18938   }
18939   jresult = SWIG_csharp_string_callback((&result)->c_str());
18940   return jresult;
18941 }
18942
18943
18944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyCount(void * jarg1) {
18945   unsigned long jresult ;
18946   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18947   size_t result;
18948
18949   arg1 = (Dali::TypeInfo *)jarg1;
18950   {
18951     try {
18952       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18953     } catch (std::out_of_range& e) {
18954       {
18955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18956       };
18957     } catch (std::exception& e) {
18958       {
18959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18960       };
18961     } catch (...) {
18962       {
18963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18964       };
18965     }
18966   }
18967   jresult = (unsigned long)result;
18968   return jresult;
18969 }
18970
18971
18972 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18973   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18974   Dali::Property::IndexContainer *arg2 = 0 ;
18975
18976   arg1 = (Dali::TypeInfo *)jarg1;
18977   arg2 = (Dali::Property::IndexContainer *)jarg2;
18978   if (!arg2) {
18979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18980     return ;
18981   }
18982   {
18983     try {
18984       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18985     } catch (std::out_of_range& e) {
18986       {
18987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18988       };
18989     } catch (std::exception& e) {
18990       {
18991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18992       };
18993     } catch (...) {
18994       {
18995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18996       };
18997     }
18998   }
18999 }
19000
19001
19002 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19003   char * jresult ;
19004   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19005   Dali::Property::Index arg2 ;
19006   std::string *result = 0 ;
19007
19008   arg1 = (Dali::TypeInfo *)jarg1;
19009   arg2 = (Dali::Property::Index)jarg2;
19010   {
19011     try {
19012       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19013     } catch (std::out_of_range& e) {
19014       {
19015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19016       };
19017     } catch (std::exception& e) {
19018       {
19019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19020       };
19021     } catch (...) {
19022       {
19023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19024       };
19025     }
19026   }
19027   jresult = SWIG_csharp_string_callback(result->c_str());
19028   return jresult;
19029 }
19030
19031
19032 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_Get() {
19033   void * jresult ;
19034   Dali::TypeRegistry result;
19035
19036   {
19037     try {
19038       result = Dali::TypeRegistry::Get();
19039     } catch (std::out_of_range& e) {
19040       {
19041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19042       };
19043     } catch (std::exception& e) {
19044       {
19045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19050       };
19051     }
19052   }
19053   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19054   return jresult;
19055 }
19056
19057
19058 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_0() {
19059   void * jresult ;
19060   Dali::TypeRegistry *result = 0 ;
19061
19062   {
19063     try {
19064       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19065     } catch (std::out_of_range& e) {
19066       {
19067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19068       };
19069     } catch (std::exception& e) {
19070       {
19071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19072       };
19073     } catch (...) {
19074       {
19075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19076       };
19077     }
19078   }
19079   jresult = (void *)result;
19080   return jresult;
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeRegistry(void * jarg1) {
19085   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19086
19087   arg1 = (Dali::TypeRegistry *)jarg1;
19088   {
19089     try {
19090       delete arg1;
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (...) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19102       };
19103     }
19104   }
19105 }
19106
19107
19108 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_1(void * jarg1) {
19109   void * jresult ;
19110   Dali::TypeRegistry *arg1 = 0 ;
19111   Dali::TypeRegistry *result = 0 ;
19112
19113   arg1 = (Dali::TypeRegistry *)jarg1;
19114   if (!arg1) {
19115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19116     return 0;
19117   }
19118   {
19119     try {
19120       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19121     } catch (std::out_of_range& e) {
19122       {
19123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19124       };
19125     } catch (std::exception& e) {
19126       {
19127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19132       };
19133     }
19134   }
19135   jresult = (void *)result;
19136   return jresult;
19137 }
19138
19139
19140 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19141   void * jresult ;
19142   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19143   Dali::TypeRegistry *arg2 = 0 ;
19144   Dali::TypeRegistry *result = 0 ;
19145
19146   arg1 = (Dali::TypeRegistry *)jarg1;
19147   arg2 = (Dali::TypeRegistry *)jarg2;
19148   if (!arg2) {
19149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19150     return 0;
19151   }
19152   {
19153     try {
19154       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19155     } catch (std::out_of_range& e) {
19156       {
19157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19158       };
19159     } catch (std::exception& e) {
19160       {
19161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (...) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19166       };
19167     }
19168   }
19169   jresult = (void *)result;
19170   return jresult;
19171 }
19172
19173
19174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19175   void * jresult ;
19176   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19177   std::string *arg2 = 0 ;
19178   Dali::TypeInfo result;
19179
19180   arg1 = (Dali::TypeRegistry *)jarg1;
19181   if (!jarg2) {
19182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19183     return 0;
19184   }
19185   std::string arg2_str(jarg2);
19186   arg2 = &arg2_str;
19187   {
19188     try {
19189       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19190     } catch (std::out_of_range& e) {
19191       {
19192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (std::exception& e) {
19195       {
19196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19201       };
19202     }
19203   }
19204   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19205
19206   //argout typemap for const std::string&
19207
19208   return jresult;
19209 }
19210
19211
19212 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19213   void * jresult ;
19214   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19215   std::type_info *arg2 = 0 ;
19216   Dali::TypeInfo result;
19217
19218   arg1 = (Dali::TypeRegistry *)jarg1;
19219   arg2 = (std::type_info *)jarg2;
19220   if (!arg2) {
19221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19222     return 0;
19223   }
19224   {
19225     try {
19226       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19227     } catch (std::out_of_range& e) {
19228       {
19229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19230       };
19231     } catch (std::exception& e) {
19232       {
19233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19238       };
19239     }
19240   }
19241   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19242   return jresult;
19243 }
19244
19245
19246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeNameCount(void * jarg1) {
19247   unsigned long jresult ;
19248   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19249   size_t result;
19250
19251   arg1 = (Dali::TypeRegistry *)jarg1;
19252   {
19253     try {
19254       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (...) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19266       };
19267     }
19268   }
19269   jresult = (unsigned long)result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19275   char * jresult ;
19276   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19277   size_t arg2 ;
19278   std::string result;
19279
19280   arg1 = (Dali::TypeRegistry *)jarg1;
19281   arg2 = (size_t)jarg2;
19282   {
19283     try {
19284       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19285     } catch (std::out_of_range& e) {
19286       {
19287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19288       };
19289     } catch (std::exception& e) {
19290       {
19291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19292       };
19293     } catch (...) {
19294       {
19295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19296       };
19297     }
19298   }
19299   jresult = SWIG_csharp_string_callback((&result)->c_str());
19300   return jresult;
19301 }
19302
19303
19304 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistry__SWIG_2(void * jarg1) {
19305   void * jresult ;
19306   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19307   Dali::TypeRegistry *result = 0 ;
19308
19309   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19310   {
19311     try {
19312       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19313     } catch (std::out_of_range& e) {
19314       {
19315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19316       };
19317     } catch (std::exception& e) {
19318       {
19319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (...) {
19322       {
19323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19324       };
19325     }
19326   }
19327   jresult = (void *)result;
19328   return jresult;
19329 }
19330
19331
19332 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19333   void * jresult ;
19334   std::type_info *arg1 = 0 ;
19335   std::type_info *arg2 = 0 ;
19336   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19337   Dali::TypeRegistration *result = 0 ;
19338
19339   arg1 = (std::type_info *)jarg1;
19340   if (!arg1) {
19341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19342     return 0;
19343   }
19344   arg2 = (std::type_info *)jarg2;
19345   if (!arg2) {
19346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19347     return 0;
19348   }
19349   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19350   {
19351     try {
19352       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19353     } catch (std::out_of_range& e) {
19354       {
19355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19356       };
19357     } catch (std::exception& e) {
19358       {
19359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (...) {
19362       {
19363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19364       };
19365     }
19366   }
19367   jresult = (void *)result;
19368   return jresult;
19369 }
19370
19371
19372 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19373   void * jresult ;
19374   std::type_info *arg1 = 0 ;
19375   std::type_info *arg2 = 0 ;
19376   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19377   bool arg4 ;
19378   Dali::TypeRegistration *result = 0 ;
19379
19380   arg1 = (std::type_info *)jarg1;
19381   if (!arg1) {
19382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19383     return 0;
19384   }
19385   arg2 = (std::type_info *)jarg2;
19386   if (!arg2) {
19387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19388     return 0;
19389   }
19390   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19391   arg4 = jarg4 ? true : false;
19392   {
19393     try {
19394       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19395     } catch (std::out_of_range& e) {
19396       {
19397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (std::exception& e) {
19400       {
19401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (...) {
19404       {
19405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19406       };
19407     }
19408   }
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19415   void * jresult ;
19416   std::string *arg1 = 0 ;
19417   std::type_info *arg2 = 0 ;
19418   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19419   Dali::TypeRegistration *result = 0 ;
19420
19421   if (!jarg1) {
19422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19423     return 0;
19424   }
19425   std::string arg1_str(jarg1);
19426   arg1 = &arg1_str;
19427   arg2 = (std::type_info *)jarg2;
19428   if (!arg2) {
19429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19430     return 0;
19431   }
19432   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19433   {
19434     try {
19435       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19436     } catch (std::out_of_range& e) {
19437       {
19438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19439       };
19440     } catch (std::exception& e) {
19441       {
19442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19443       };
19444     } catch (...) {
19445       {
19446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19447       };
19448     }
19449   }
19450   jresult = (void *)result;
19451
19452   //argout typemap for const std::string&
19453
19454   return jresult;
19455 }
19456
19457
19458 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_TypeRegistration_RegisteredName(void * jarg1) {
19459   char * jresult ;
19460   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19461   std::string result;
19462
19463   arg1 = (Dali::TypeRegistration *)jarg1;
19464   {
19465     try {
19466       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19467     } catch (std::out_of_range& e) {
19468       {
19469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19470       };
19471     } catch (std::exception& e) {
19472       {
19473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19474       };
19475     } catch (...) {
19476       {
19477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19478       };
19479     }
19480   }
19481   jresult = SWIG_csharp_string_callback((&result)->c_str());
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeRegistration(void * jarg1) {
19487   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19488
19489   arg1 = (Dali::TypeRegistration *)jarg1;
19490   {
19491     try {
19492       delete arg1;
19493     } catch (std::out_of_range& e) {
19494       {
19495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19496       };
19497     } catch (std::exception& e) {
19498       {
19499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19500       };
19501     } catch (...) {
19502       {
19503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19504       };
19505     }
19506   }
19507 }
19508
19509
19510 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19511   void * jresult ;
19512   Dali::TypeRegistration *arg1 = 0 ;
19513   std::string *arg2 = 0 ;
19514   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19515   Dali::SignalConnectorType *result = 0 ;
19516
19517   arg1 = (Dali::TypeRegistration *)jarg1;
19518   if (!arg1) {
19519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19520     return 0;
19521   }
19522   if (!jarg2) {
19523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19524     return 0;
19525   }
19526   std::string arg2_str(jarg2);
19527   arg2 = &arg2_str;
19528   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19529   {
19530     try {
19531       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19543       };
19544     }
19545   }
19546   jresult = (void *)result;
19547
19548   //argout typemap for const std::string&
19549
19550   return jresult;
19551 }
19552
19553
19554 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SignalConnectorType(void * jarg1) {
19555   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19556
19557   arg1 = (Dali::SignalConnectorType *)jarg1;
19558   {
19559     try {
19560       delete arg1;
19561     } catch (std::out_of_range& e) {
19562       {
19563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19564       };
19565     } catch (std::exception& e) {
19566       {
19567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19568       };
19569     } catch (...) {
19570       {
19571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19572       };
19573     }
19574   }
19575 }
19576
19577
19578 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19579   void * jresult ;
19580   Dali::TypeRegistration *arg1 = 0 ;
19581   std::string *arg2 = 0 ;
19582   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19583   Dali::TypeAction *result = 0 ;
19584
19585   arg1 = (Dali::TypeRegistration *)jarg1;
19586   if (!arg1) {
19587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19588     return 0;
19589   }
19590   if (!jarg2) {
19591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19592     return 0;
19593   }
19594   std::string arg2_str(jarg2);
19595   arg2 = &arg2_str;
19596   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19597   {
19598     try {
19599       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19600     } catch (std::out_of_range& e) {
19601       {
19602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19603       };
19604     } catch (std::exception& e) {
19605       {
19606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19607       };
19608     } catch (...) {
19609       {
19610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19611       };
19612     }
19613   }
19614   jresult = (void *)result;
19615
19616   //argout typemap for const std::string&
19617
19618   return jresult;
19619 }
19620
19621
19622 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TypeAction(void * jarg1) {
19623   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19624
19625   arg1 = (Dali::TypeAction *)jarg1;
19626   {
19627     try {
19628       delete arg1;
19629     } catch (std::out_of_range& e) {
19630       {
19631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19632       };
19633     } catch (std::exception& e) {
19634       {
19635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19636       };
19637     } catch (...) {
19638       {
19639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19640       };
19641     }
19642   }
19643 }
19644
19645
19646 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19647   void * jresult ;
19648   Dali::TypeRegistration *arg1 = 0 ;
19649   std::string *arg2 = 0 ;
19650   Dali::Property::Index arg3 ;
19651   Dali::Property::Type arg4 ;
19652   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19653   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19654   Dali::PropertyRegistration *result = 0 ;
19655
19656   arg1 = (Dali::TypeRegistration *)jarg1;
19657   if (!arg1) {
19658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19659     return 0;
19660   }
19661   if (!jarg2) {
19662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19663     return 0;
19664   }
19665   std::string arg2_str(jarg2);
19666   arg2 = &arg2_str;
19667   arg3 = (Dali::Property::Index)jarg3;
19668   arg4 = (Dali::Property::Type)jarg4;
19669   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19670   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19671   {
19672     try {
19673       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19674     } catch (std::out_of_range& e) {
19675       {
19676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19677       };
19678     } catch (std::exception& e) {
19679       {
19680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19681       };
19682     } catch (...) {
19683       {
19684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19685       };
19686     }
19687   }
19688   jresult = (void *)result;
19689
19690   //argout typemap for const std::string&
19691
19692   return jresult;
19693 }
19694
19695
19696 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyRegistration(void * jarg1) {
19697   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19698
19699   arg1 = (Dali::PropertyRegistration *)jarg1;
19700   {
19701     try {
19702       delete arg1;
19703     } catch (std::out_of_range& e) {
19704       {
19705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19706       };
19707     } catch (std::exception& e) {
19708       {
19709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19710       };
19711     } catch (...) {
19712       {
19713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19714       };
19715     }
19716   }
19717 }
19718
19719
19720 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19721   void * jresult ;
19722   Dali::TypeRegistration *arg1 = 0 ;
19723   std::string *arg2 = 0 ;
19724   Dali::Property::Index arg3 ;
19725   Dali::Property::Type arg4 ;
19726   Dali::AnimatablePropertyRegistration *result = 0 ;
19727
19728   arg1 = (Dali::TypeRegistration *)jarg1;
19729   if (!arg1) {
19730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19731     return 0;
19732   }
19733   if (!jarg2) {
19734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19735     return 0;
19736   }
19737   std::string arg2_str(jarg2);
19738   arg2 = &arg2_str;
19739   arg3 = (Dali::Property::Index)jarg3;
19740   arg4 = (Dali::Property::Type)jarg4;
19741   {
19742     try {
19743       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19744     } catch (std::out_of_range& e) {
19745       {
19746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19747       };
19748     } catch (std::exception& e) {
19749       {
19750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19751       };
19752     } catch (...) {
19753       {
19754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19755       };
19756     }
19757   }
19758   jresult = (void *)result;
19759
19760   //argout typemap for const std::string&
19761
19762   return jresult;
19763 }
19764
19765
19766 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19767   void * jresult ;
19768   Dali::TypeRegistration *arg1 = 0 ;
19769   std::string *arg2 = 0 ;
19770   Dali::Property::Index arg3 ;
19771   Dali::Property::Value *arg4 = 0 ;
19772   Dali::AnimatablePropertyRegistration *result = 0 ;
19773
19774   arg1 = (Dali::TypeRegistration *)jarg1;
19775   if (!arg1) {
19776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19777     return 0;
19778   }
19779   if (!jarg2) {
19780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19781     return 0;
19782   }
19783   std::string arg2_str(jarg2);
19784   arg2 = &arg2_str;
19785   arg3 = (Dali::Property::Index)jarg3;
19786   arg4 = (Dali::Property::Value *)jarg4;
19787   if (!arg4) {
19788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19789     return 0;
19790   }
19791   {
19792     try {
19793       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19794     } catch (std::out_of_range& e) {
19795       {
19796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19797       };
19798     } catch (std::exception& e) {
19799       {
19800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (...) {
19803       {
19804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19805       };
19806     }
19807   }
19808   jresult = (void *)result;
19809
19810   //argout typemap for const std::string&
19811
19812   return jresult;
19813 }
19814
19815
19816 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimatablePropertyRegistration(void * jarg1) {
19817   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19818
19819   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19820   {
19821     try {
19822       delete arg1;
19823     } catch (std::out_of_range& e) {
19824       {
19825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19826       };
19827     } catch (std::exception& e) {
19828       {
19829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19830       };
19831     } catch (...) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19834       };
19835     }
19836   }
19837 }
19838
19839
19840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19841   void * jresult ;
19842   Dali::TypeRegistration *arg1 = 0 ;
19843   std::string *arg2 = 0 ;
19844   Dali::Property::Index arg3 ;
19845   Dali::Property::Index arg4 ;
19846   unsigned int arg5 ;
19847   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19848
19849   arg1 = (Dali::TypeRegistration *)jarg1;
19850   if (!arg1) {
19851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19852     return 0;
19853   }
19854   if (!jarg2) {
19855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19856     return 0;
19857   }
19858   std::string arg2_str(jarg2);
19859   arg2 = &arg2_str;
19860   arg3 = (Dali::Property::Index)jarg3;
19861   arg4 = (Dali::Property::Index)jarg4;
19862   arg5 = (unsigned int)jarg5;
19863   {
19864     try {
19865       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19866     } catch (std::out_of_range& e) {
19867       {
19868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19869       };
19870     } catch (std::exception& e) {
19871       {
19872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (...) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19877       };
19878     }
19879   }
19880   jresult = (void *)result;
19881
19882   //argout typemap for const std::string&
19883
19884   return jresult;
19885 }
19886
19887
19888 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19889   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19890
19891   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19892   {
19893     try {
19894       delete arg1;
19895     } catch (std::out_of_range& e) {
19896       {
19897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19898       };
19899     } catch (std::exception& e) {
19900       {
19901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (...) {
19904       {
19905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19906       };
19907     }
19908   }
19909 }
19910
19911
19912 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19913   void * jresult ;
19914   Dali::TypeRegistration *arg1 = 0 ;
19915   std::string *arg2 = 0 ;
19916   Dali::Property::Index arg3 ;
19917   Dali::Property::Type arg4 ;
19918   Dali::ChildPropertyRegistration *result = 0 ;
19919
19920   arg1 = (Dali::TypeRegistration *)jarg1;
19921   if (!arg1) {
19922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19923     return 0;
19924   }
19925   if (!jarg2) {
19926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19927     return 0;
19928   }
19929   std::string arg2_str(jarg2);
19930   arg2 = &arg2_str;
19931   arg3 = (Dali::Property::Index)jarg3;
19932   arg4 = (Dali::Property::Type)jarg4;
19933   {
19934     try {
19935       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (...) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19947       };
19948     }
19949   }
19950   jresult = (void *)result;
19951
19952   //argout typemap for const std::string&
19953
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ChildPropertyRegistration(void * jarg1) {
19959   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19960
19961   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19962   {
19963     try {
19964       delete arg1;
19965     } catch (std::out_of_range& e) {
19966       {
19967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19968       };
19969     } catch (std::exception& e) {
19970       {
19971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19972       };
19973     } catch (...) {
19974       {
19975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19976       };
19977     }
19978   }
19979 }
19980
19981
19982 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginTop_get() {
19983   float jresult ;
19984   float result;
19985
19986   result = (float)(float)Dali::ParentOrigin::TOP;
19987   jresult = result;
19988   return jresult;
19989 }
19990
19991
19992 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginBottom_get() {
19993   float jresult ;
19994   float result;
19995
19996   result = (float)(float)Dali::ParentOrigin::BOTTOM;
19997   jresult = result;
19998   return jresult;
19999 }
20000
20001
20002 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginLeft_get() {
20003   float jresult ;
20004   float result;
20005
20006   result = (float)(float)Dali::ParentOrigin::LEFT;
20007   jresult = result;
20008   return jresult;
20009 }
20010
20011
20012 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginRight_get() {
20013   float jresult ;
20014   float result;
20015
20016   result = (float)(float)Dali::ParentOrigin::RIGHT;
20017   jresult = result;
20018   return jresult;
20019 }
20020
20021
20022 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ParentOriginMiddle_get() {
20023   float jresult ;
20024   float result;
20025
20026   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20027   jresult = result;
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopLeft_get() {
20033   void * jresult ;
20034   Dali::Vector3 *result = 0 ;
20035
20036   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20037   jresult = (void *)result;
20038   return jresult;
20039 }
20040
20041
20042 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopCenter_get() {
20043   void * jresult ;
20044   Dali::Vector3 *result = 0 ;
20045
20046   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20047   jresult = (void *)result;
20048   return jresult;
20049 }
20050
20051
20052 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginTopRight_get() {
20053   void * jresult ;
20054   Dali::Vector3 *result = 0 ;
20055
20056   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20057   jresult = (void *)result;
20058   return jresult;
20059 }
20060
20061
20062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenterLeft_get() {
20063   void * jresult ;
20064   Dali::Vector3 *result = 0 ;
20065
20066   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20067   jresult = (void *)result;
20068   return jresult;
20069 }
20070
20071
20072 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenter_get() {
20073   void * jresult ;
20074   Dali::Vector3 *result = 0 ;
20075
20076   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20077   jresult = (void *)result;
20078   return jresult;
20079 }
20080
20081
20082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginCenterRight_get() {
20083   void * jresult ;
20084   Dali::Vector3 *result = 0 ;
20085
20086   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20087   jresult = (void *)result;
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomLeft_get() {
20093   void * jresult ;
20094   Dali::Vector3 *result = 0 ;
20095
20096   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20097   jresult = (void *)result;
20098   return jresult;
20099 }
20100
20101
20102 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomCenter_get() {
20103   void * jresult ;
20104   Dali::Vector3 *result = 0 ;
20105
20106   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20107   jresult = (void *)result;
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ParentOriginBottomRight_get() {
20113   void * jresult ;
20114   Dali::Vector3 *result = 0 ;
20115
20116   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20117   jresult = (void *)result;
20118   return jresult;
20119 }
20120
20121
20122 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointTop_get() {
20123   float jresult ;
20124   float result;
20125
20126   result = (float)(float)Dali::AnchorPoint::TOP;
20127   jresult = result;
20128   return jresult;
20129 }
20130
20131
20132 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointBottom_get() {
20133   float jresult ;
20134   float result;
20135
20136   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20137   jresult = result;
20138   return jresult;
20139 }
20140
20141
20142 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointLeft_get() {
20143   float jresult ;
20144   float result;
20145
20146   result = (float)(float)Dali::AnchorPoint::LEFT;
20147   jresult = result;
20148   return jresult;
20149 }
20150
20151
20152 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointRight_get() {
20153   float jresult ;
20154   float result;
20155
20156   result = (float)(float)Dali::AnchorPoint::RIGHT;
20157   jresult = result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_AnchorPointMiddle_get() {
20163   float jresult ;
20164   float result;
20165
20166   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20167   jresult = result;
20168   return jresult;
20169 }
20170
20171
20172 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopLeft_get() {
20173   void * jresult ;
20174   Dali::Vector3 *result = 0 ;
20175
20176   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20177   jresult = (void *)result;
20178   return jresult;
20179 }
20180
20181
20182 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopCenter_get() {
20183   void * jresult ;
20184   Dali::Vector3 *result = 0 ;
20185
20186   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20187   jresult = (void *)result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointTopRight_get() {
20193   void * jresult ;
20194   Dali::Vector3 *result = 0 ;
20195
20196   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20197   jresult = (void *)result;
20198   return jresult;
20199 }
20200
20201
20202 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenterLeft_get() {
20203   void * jresult ;
20204   Dali::Vector3 *result = 0 ;
20205
20206   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20207   jresult = (void *)result;
20208   return jresult;
20209 }
20210
20211
20212 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenter_get() {
20213   void * jresult ;
20214   Dali::Vector3 *result = 0 ;
20215
20216   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20217   jresult = (void *)result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointCenterRight_get() {
20223   void * jresult ;
20224   Dali::Vector3 *result = 0 ;
20225
20226   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20227   jresult = (void *)result;
20228   return jresult;
20229 }
20230
20231
20232 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomLeft_get() {
20233   void * jresult ;
20234   Dali::Vector3 *result = 0 ;
20235
20236   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20237   jresult = (void *)result;
20238   return jresult;
20239 }
20240
20241
20242 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomCenter_get() {
20243   void * jresult ;
20244   Dali::Vector3 *result = 0 ;
20245
20246   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20247   jresult = (void *)result;
20248   return jresult;
20249 }
20250
20251
20252 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AnchorPointBottomRight_get() {
20253   void * jresult ;
20254   Dali::Vector3 *result = 0 ;
20255
20256   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20257   jresult = (void *)result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BLACK_get() {
20263   void * jresult ;
20264   Dali::Vector4 *result = 0 ;
20265
20266   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20267   jresult = (void *)result;
20268   return jresult;
20269 }
20270
20271
20272 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_WHITE_get() {
20273   void * jresult ;
20274   Dali::Vector4 *result = 0 ;
20275
20276   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20277   jresult = (void *)result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RED_get() {
20283   void * jresult ;
20284   Dali::Vector4 *result = 0 ;
20285
20286   result = (Dali::Vector4 *)&Dali::Color::RED;
20287   jresult = (void *)result;
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GREEN_get() {
20293   void * jresult ;
20294   Dali::Vector4 *result = 0 ;
20295
20296   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20297   jresult = (void *)result;
20298   return jresult;
20299 }
20300
20301
20302 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BLUE_get() {
20303   void * jresult ;
20304   Dali::Vector4 *result = 0 ;
20305
20306   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20307   jresult = (void *)result;
20308   return jresult;
20309 }
20310
20311
20312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_YELLOW_get() {
20313   void * jresult ;
20314   Dali::Vector4 *result = 0 ;
20315
20316   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20317   jresult = (void *)result;
20318   return jresult;
20319 }
20320
20321
20322 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_MAGENTA_get() {
20323   void * jresult ;
20324   Dali::Vector4 *result = 0 ;
20325
20326   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20327   jresult = (void *)result;
20328   return jresult;
20329 }
20330
20331
20332 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CYAN_get() {
20333   void * jresult ;
20334   Dali::Vector4 *result = 0 ;
20335
20336   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20337   jresult = (void *)result;
20338   return jresult;
20339 }
20340
20341
20342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TRANSPARENT_get() {
20343   void * jresult ;
20344   Dali::Vector4 *result = 0 ;
20345
20346   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20347   jresult = (void *)result;
20348   return jresult;
20349 }
20350
20351
20352 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_0_get() {
20353   float jresult ;
20354   float result;
20355
20356   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20357   jresult = result;
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_1_get() {
20363   float jresult ;
20364   float result;
20365
20366   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20367   jresult = result;
20368   return jresult;
20369 }
20370
20371
20372 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_10_get() {
20373   float jresult ;
20374   float result;
20375
20376   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20377   jresult = result;
20378   return jresult;
20379 }
20380
20381
20382 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_100_get() {
20383   float jresult ;
20384   float result;
20385
20386   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20387   jresult = result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_1000_get() {
20393   float jresult ;
20394   float result;
20395
20396   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20397   jresult = result;
20398   return jresult;
20399 }
20400
20401
20402 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_MACHINE_EPSILON_10000_get() {
20403   float jresult ;
20404   float result;
20405
20406   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20407   jresult = result;
20408   return jresult;
20409 }
20410
20411
20412 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_get() {
20413   float jresult ;
20414   float result;
20415
20416   result = (float)(float)Dali::Math::PI;
20417   jresult = result;
20418   return jresult;
20419 }
20420
20421
20422 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_2_get() {
20423   float jresult ;
20424   float result;
20425
20426   result = (float)(float)Dali::Math::PI_2;
20427   jresult = result;
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_4_get() {
20433   float jresult ;
20434   float result;
20435
20436   result = (float)(float)Dali::Math::PI_4;
20437   jresult = result;
20438   return jresult;
20439 }
20440
20441
20442 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PI_OVER_180_get() {
20443   float jresult ;
20444   float result;
20445
20446   result = (float)(float)Dali::Math::PI_OVER_180;
20447   jresult = result;
20448   return jresult;
20449 }
20450
20451
20452 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ONE80_OVER_PI_get() {
20453   float jresult ;
20454   float result;
20455
20456   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20457   jresult = result;
20458   return jresult;
20459 }
20460
20461
20462 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ResizePolicyDefault_get() {
20463   int jresult ;
20464   Dali::ResizePolicy::Type result;
20465
20466   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20467   jresult = (int)result;
20468   return jresult;
20469 }
20470
20471
20472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Count(void * jarg1) {
20473   unsigned long jresult ;
20474   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20475   Dali::VectorBase::SizeType result;
20476
20477   arg1 = (Dali::VectorBase *)jarg1;
20478   {
20479     try {
20480       result = ((Dali::VectorBase const *)arg1)->Count();
20481     } catch (std::out_of_range& e) {
20482       {
20483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20484       };
20485     } catch (std::exception& e) {
20486       {
20487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20488       };
20489     } catch (...) {
20490       {
20491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20492       };
20493     }
20494   }
20495   jresult = (unsigned long)result;
20496   return jresult;
20497 }
20498
20499
20500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Size(void * jarg1) {
20501   unsigned long jresult ;
20502   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20503   Dali::VectorBase::SizeType result;
20504
20505   arg1 = (Dali::VectorBase *)jarg1;
20506   {
20507     try {
20508       result = ((Dali::VectorBase const *)arg1)->Size();
20509     } catch (std::out_of_range& e) {
20510       {
20511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20512       };
20513     } catch (std::exception& e) {
20514       {
20515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (...) {
20518       {
20519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20520       };
20521     }
20522   }
20523   jresult = (unsigned long)result;
20524   return jresult;
20525 }
20526
20527
20528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VectorBase_Empty(void * jarg1) {
20529   unsigned int jresult ;
20530   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20531   bool result;
20532
20533   arg1 = (Dali::VectorBase *)jarg1;
20534   {
20535     try {
20536       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20537     } catch (std::out_of_range& e) {
20538       {
20539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20540       };
20541     } catch (std::exception& e) {
20542       {
20543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20544       };
20545     } catch (...) {
20546       {
20547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20548       };
20549     }
20550   }
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VectorBase_Capacity(void * jarg1) {
20557   unsigned long jresult ;
20558   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20559   Dali::VectorBase::SizeType result;
20560
20561   arg1 = (Dali::VectorBase *)jarg1;
20562   {
20563     try {
20564       result = ((Dali::VectorBase const *)arg1)->Capacity();
20565     } catch (std::out_of_range& e) {
20566       {
20567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20568       };
20569     } catch (std::exception& e) {
20570       {
20571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20572       };
20573     } catch (...) {
20574       {
20575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20576       };
20577     }
20578   }
20579   jresult = (unsigned long)result;
20580   return jresult;
20581 }
20582
20583
20584 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorBase_Release(void * jarg1) {
20585   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20586
20587   arg1 = (Dali::VectorBase *)jarg1;
20588   {
20589     try {
20590       (arg1)->Release();
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20598       };
20599     } catch (...) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20602       };
20603     }
20604   }
20605 }
20606
20607
20608 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Image__SWIG_0() {
20609   void * jresult ;
20610   Dali::Image *result = 0 ;
20611
20612   {
20613     try {
20614       result = (Dali::Image *)new Dali::Image();
20615     } catch (std::out_of_range& e) {
20616       {
20617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20618       };
20619     } catch (std::exception& e) {
20620       {
20621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20622       };
20623     } catch (...) {
20624       {
20625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20626       };
20627     }
20628   }
20629   jresult = (void *)result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Image(void * jarg1) {
20635   Dali::Image *arg1 = (Dali::Image *) 0 ;
20636
20637   arg1 = (Dali::Image *)jarg1;
20638   {
20639     try {
20640       delete arg1;
20641     } catch (std::out_of_range& e) {
20642       {
20643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20644       };
20645     } catch (std::exception& e) {
20646       {
20647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20648       };
20649     } catch (...) {
20650       {
20651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20652       };
20653     }
20654   }
20655 }
20656
20657
20658 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Image__SWIG_1(void * jarg1) {
20659   void * jresult ;
20660   Dali::Image *arg1 = 0 ;
20661   Dali::Image *result = 0 ;
20662
20663   arg1 = (Dali::Image *)jarg1;
20664   if (!arg1) {
20665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20666     return 0;
20667   }
20668   {
20669     try {
20670       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20671     } catch (std::out_of_range& e) {
20672       {
20673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20674       };
20675     } catch (std::exception& e) {
20676       {
20677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20678       };
20679     } catch (...) {
20680       {
20681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20682       };
20683     }
20684   }
20685   jresult = (void *)result;
20686   return jresult;
20687 }
20688
20689
20690 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_Assign(void * jarg1, void * jarg2) {
20691   void * jresult ;
20692   Dali::Image *arg1 = (Dali::Image *) 0 ;
20693   Dali::Image *arg2 = 0 ;
20694   Dali::Image *result = 0 ;
20695
20696   arg1 = (Dali::Image *)jarg1;
20697   arg2 = (Dali::Image *)jarg2;
20698   if (!arg2) {
20699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20700     return 0;
20701   }
20702   {
20703     try {
20704       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20705     } catch (std::out_of_range& e) {
20706       {
20707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20708       };
20709     } catch (std::exception& e) {
20710       {
20711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20712       };
20713     } catch (...) {
20714       {
20715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20716       };
20717     }
20718   }
20719   jresult = (void *)result;
20720   return jresult;
20721 }
20722
20723
20724 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_DownCast(void * jarg1) {
20725   void * jresult ;
20726   Dali::BaseHandle arg1 ;
20727   Dali::BaseHandle *argp1 ;
20728   Dali::Image result;
20729
20730   argp1 = (Dali::BaseHandle *)jarg1;
20731   if (!argp1) {
20732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20733     return 0;
20734   }
20735   arg1 = *argp1;
20736   {
20737     try {
20738       result = Dali::Image::DownCast(arg1);
20739     } catch (std::out_of_range& e) {
20740       {
20741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20742       };
20743     } catch (std::exception& e) {
20744       {
20745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20750       };
20751     }
20752   }
20753   jresult = new Dali::Image((const Dali::Image &)result);
20754   return jresult;
20755 }
20756
20757
20758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Image_GetWidth(void * jarg1) {
20759   unsigned int jresult ;
20760   Dali::Image *arg1 = (Dali::Image *) 0 ;
20761   unsigned int result;
20762
20763   arg1 = (Dali::Image *)jarg1;
20764   {
20765     try {
20766       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20767     } catch (std::out_of_range& e) {
20768       {
20769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20770       };
20771     } catch (std::exception& e) {
20772       {
20773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20774       };
20775     } catch (...) {
20776       {
20777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20778       };
20779     }
20780   }
20781   jresult = result;
20782   return jresult;
20783 }
20784
20785
20786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Image_GetHeight(void * jarg1) {
20787   unsigned int jresult ;
20788   Dali::Image *arg1 = (Dali::Image *) 0 ;
20789   unsigned int result;
20790
20791   arg1 = (Dali::Image *)jarg1;
20792   {
20793     try {
20794       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20795     } catch (std::out_of_range& e) {
20796       {
20797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20798       };
20799     } catch (std::exception& e) {
20800       {
20801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (...) {
20804       {
20805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20806       };
20807     }
20808   }
20809   jresult = result;
20810   return jresult;
20811 }
20812
20813
20814 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Image_UploadedSignal(void * jarg1) {
20815   void * jresult ;
20816   Dali::Image *arg1 = (Dali::Image *) 0 ;
20817   Dali::Image::ImageSignalType *result = 0 ;
20818
20819   arg1 = (Dali::Image *)jarg1;
20820   {
20821     try {
20822       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20823     } catch (std::out_of_range& e) {
20824       {
20825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20826       };
20827     } catch (std::exception& e) {
20828       {
20829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (...) {
20832       {
20833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20834       };
20835     }
20836   }
20837   jresult = (void *)result;
20838   return jresult;
20839 }
20840
20841
20842 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FIRST_VALID_PIXEL_FORMAT_get() {
20843   int jresult ;
20844   Dali::Pixel::Format result;
20845
20846   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20847   jresult = (int)result;
20848   return jresult;
20849 }
20850
20851
20852 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LAST_VALID_PIXEL_FORMAT_get() {
20853   int jresult ;
20854   Dali::Pixel::Format result;
20855
20856   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20857   jresult = (int)result;
20858   return jresult;
20859 }
20860
20861
20862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_HasAlpha(int jarg1) {
20863   unsigned int jresult ;
20864   Dali::Pixel::Format arg1 ;
20865   bool result;
20866
20867   arg1 = (Dali::Pixel::Format)jarg1;
20868   {
20869     try {
20870       result = (bool)Dali::Pixel::HasAlpha(arg1);
20871     } catch (std::out_of_range& e) {
20872       {
20873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20874       };
20875     } catch (std::exception& e) {
20876       {
20877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20878       };
20879     } catch (...) {
20880       {
20881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20882       };
20883     }
20884   }
20885   jresult = result;
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GetBytesPerPixel(int jarg1) {
20891   unsigned int jresult ;
20892   Dali::Pixel::Format arg1 ;
20893   unsigned int result;
20894
20895   arg1 = (Dali::Pixel::Format)jarg1;
20896   {
20897     try {
20898       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20899     } catch (std::out_of_range& e) {
20900       {
20901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20902       };
20903     } catch (std::exception& e) {
20904       {
20905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (...) {
20908       {
20909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20910       };
20911     }
20912   }
20913   jresult = result;
20914   return jresult;
20915 }
20916
20917
20918 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
20919   Dali::Pixel::Format arg1 ;
20920   int *arg2 = 0 ;
20921   int *arg3 = 0 ;
20922
20923   arg1 = (Dali::Pixel::Format)jarg1;
20924   arg2 = (int *)jarg2;
20925   if (!arg2) {
20926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
20927     return ;
20928   }
20929   arg3 = (int *)jarg3;
20930   if (!arg3) {
20931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
20932     return ;
20933   }
20934   {
20935     try {
20936       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
20937     } catch (std::out_of_range& e) {
20938       {
20939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20940       };
20941     } catch (std::exception& e) {
20942       {
20943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20944       };
20945     } catch (...) {
20946       {
20947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20948       };
20949     }
20950   }
20951 }
20952
20953
20954 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
20955   void * jresult ;
20956   unsigned char *arg1 = (unsigned char *) 0 ;
20957   unsigned int arg2 ;
20958   unsigned int arg3 ;
20959   unsigned int arg4 ;
20960   Dali::Pixel::Format arg5 ;
20961   Dali::PixelData::ReleaseFunction arg6 ;
20962   Dali::PixelData result;
20963
20964   arg1 = jarg1;
20965   arg2 = (unsigned int)jarg2;
20966   arg3 = (unsigned int)jarg3;
20967   arg4 = (unsigned int)jarg4;
20968   arg5 = (Dali::Pixel::Format)jarg5;
20969   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
20970   {
20971     try {
20972       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
20973     } catch (std::out_of_range& e) {
20974       {
20975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20976       };
20977     } catch (std::exception& e) {
20978       {
20979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20980       };
20981     } catch (...) {
20982       {
20983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20984       };
20985     }
20986   }
20987   jresult = new Dali::PixelData((const Dali::PixelData &)result);
20988
20989
20990   return jresult;
20991 }
20992
20993
20994 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PixelData__SWIG_0() {
20995   void * jresult ;
20996   Dali::PixelData *result = 0 ;
20997
20998   {
20999     try {
21000       result = (Dali::PixelData *)new Dali::PixelData();
21001     } catch (std::out_of_range& e) {
21002       {
21003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21004       };
21005     } catch (std::exception& e) {
21006       {
21007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21008       };
21009     } catch (...) {
21010       {
21011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21012       };
21013     }
21014   }
21015   jresult = (void *)result;
21016   return jresult;
21017 }
21018
21019
21020 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PixelData(void * jarg1) {
21021   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21022
21023   arg1 = (Dali::PixelData *)jarg1;
21024   {
21025     try {
21026       delete arg1;
21027     } catch (std::out_of_range& e) {
21028       {
21029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21030       };
21031     } catch (std::exception& e) {
21032       {
21033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21034       };
21035     } catch (...) {
21036       {
21037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21038       };
21039     }
21040   }
21041 }
21042
21043
21044 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PixelData__SWIG_1(void * jarg1) {
21045   void * jresult ;
21046   Dali::PixelData *arg1 = 0 ;
21047   Dali::PixelData *result = 0 ;
21048
21049   arg1 = (Dali::PixelData *)jarg1;
21050   if (!arg1) {
21051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21052     return 0;
21053   }
21054   {
21055     try {
21056       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21057     } catch (std::out_of_range& e) {
21058       {
21059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21060       };
21061     } catch (std::exception& e) {
21062       {
21063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21068       };
21069     }
21070   }
21071   jresult = (void *)result;
21072   return jresult;
21073 }
21074
21075
21076 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PixelData_Assign(void * jarg1, void * jarg2) {
21077   void * jresult ;
21078   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21079   Dali::PixelData *arg2 = 0 ;
21080   Dali::PixelData *result = 0 ;
21081
21082   arg1 = (Dali::PixelData *)jarg1;
21083   arg2 = (Dali::PixelData *)jarg2;
21084   if (!arg2) {
21085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21086     return 0;
21087   }
21088   {
21089     try {
21090       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21091     } catch (std::out_of_range& e) {
21092       {
21093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21094       };
21095     } catch (std::exception& e) {
21096       {
21097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21098       };
21099     } catch (...) {
21100       {
21101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21102       };
21103     }
21104   }
21105   jresult = (void *)result;
21106   return jresult;
21107 }
21108
21109
21110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PixelData_GetWidth(void * jarg1) {
21111   unsigned int jresult ;
21112   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21113   unsigned int result;
21114
21115   arg1 = (Dali::PixelData *)jarg1;
21116   {
21117     try {
21118       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21119     } catch (std::out_of_range& e) {
21120       {
21121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21122       };
21123     } catch (std::exception& e) {
21124       {
21125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21130       };
21131     }
21132   }
21133   jresult = result;
21134   return jresult;
21135 }
21136
21137
21138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PixelData_GetHeight(void * jarg1) {
21139   unsigned int jresult ;
21140   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21141   unsigned int result;
21142
21143   arg1 = (Dali::PixelData *)jarg1;
21144   {
21145     try {
21146       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21147     } catch (std::out_of_range& e) {
21148       {
21149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21150       };
21151     } catch (std::exception& e) {
21152       {
21153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (...) {
21156       {
21157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21158       };
21159     }
21160   }
21161   jresult = result;
21162   return jresult;
21163 }
21164
21165
21166 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PixelData_GetPixelFormat(void * jarg1) {
21167   int jresult ;
21168   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21169   Dali::Pixel::Format result;
21170
21171   arg1 = (Dali::PixelData *)jarg1;
21172   {
21173     try {
21174       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21175     } catch (std::out_of_range& e) {
21176       {
21177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21178       };
21179     } catch (std::exception& e) {
21180       {
21181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21182       };
21183     } catch (...) {
21184       {
21185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21186       };
21187     }
21188   }
21189   jresult = (int)result;
21190   return jresult;
21191 }
21192
21193
21194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_X_get() {
21195   unsigned int jresult ;
21196   unsigned int result;
21197
21198   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21199   jresult = result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_X_get() {
21205   unsigned int jresult ;
21206   unsigned int result;
21207
21208   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21209   jresult = result;
21210   return jresult;
21211 }
21212
21213
21214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_Y_get() {
21215   unsigned int jresult ;
21216   unsigned int result;
21217
21218   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21219   jresult = result;
21220   return jresult;
21221 }
21222
21223
21224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_Y_get() {
21225   unsigned int jresult ;
21226   unsigned int result;
21227
21228   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21229   jresult = result;
21230   return jresult;
21231 }
21232
21233
21234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_POSITIVE_Z_get() {
21235   unsigned int jresult ;
21236   unsigned int result;
21237
21238   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21239   jresult = result;
21240   return jresult;
21241 }
21242
21243
21244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NEGATIVE_Z_get() {
21245   unsigned int jresult ;
21246   unsigned int result;
21247
21248   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21249   jresult = result;
21250   return jresult;
21251 }
21252
21253
21254 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21255   void * jresult ;
21256   Dali::TextureType::Type arg1 ;
21257   Dali::Pixel::Format arg2 ;
21258   unsigned int arg3 ;
21259   unsigned int arg4 ;
21260   Dali::Texture result;
21261
21262   arg1 = (Dali::TextureType::Type)jarg1;
21263   arg2 = (Dali::Pixel::Format)jarg2;
21264   arg3 = (unsigned int)jarg3;
21265   arg4 = (unsigned int)jarg4;
21266   {
21267     try {
21268       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21269     } catch (std::out_of_range& e) {
21270       {
21271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21272       };
21273     } catch (std::exception& e) {
21274       {
21275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21276       };
21277     } catch (...) {
21278       {
21279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21280       };
21281     }
21282   }
21283   jresult = new Dali::Texture((const Dali::Texture &)result);
21284   return jresult;
21285 }
21286
21287
21288 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_New__SWIG_1(void * jarg1) {
21289   void * jresult ;
21290   NativeImageInterface *arg1 = 0 ;
21291   Dali::Texture result;
21292
21293   arg1 = (NativeImageInterface *)jarg1;
21294   if (!arg1) {
21295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21296     return 0;
21297   }
21298   {
21299     try {
21300       result = Dali::Texture::New(*arg1);
21301     } catch (std::out_of_range& e) {
21302       {
21303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21304       };
21305     } catch (std::exception& e) {
21306       {
21307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21308       };
21309     } catch (...) {
21310       {
21311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21312       };
21313     }
21314   }
21315   jresult = new Dali::Texture((const Dali::Texture &)result);
21316   return jresult;
21317 }
21318
21319
21320 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Texture__SWIG_0() {
21321   void * jresult ;
21322   Dali::Texture *result = 0 ;
21323
21324   {
21325     try {
21326       result = (Dali::Texture *)new Dali::Texture();
21327     } catch (std::out_of_range& e) {
21328       {
21329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (std::exception& e) {
21332       {
21333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341   jresult = (void *)result;
21342   return jresult;
21343 }
21344
21345
21346 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Texture(void * jarg1) {
21347   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21348
21349   arg1 = (Dali::Texture *)jarg1;
21350   {
21351     try {
21352       delete arg1;
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21360       };
21361     } catch (...) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21364       };
21365     }
21366   }
21367 }
21368
21369
21370 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Texture__SWIG_1(void * jarg1) {
21371   void * jresult ;
21372   Dali::Texture *arg1 = 0 ;
21373   Dali::Texture *result = 0 ;
21374
21375   arg1 = (Dali::Texture *)jarg1;
21376   if (!arg1) {
21377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21378     return 0;
21379   }
21380   {
21381     try {
21382       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21383     } catch (std::out_of_range& e) {
21384       {
21385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21386       };
21387     } catch (std::exception& e) {
21388       {
21389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (...) {
21392       {
21393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21394       };
21395     }
21396   }
21397   jresult = (void *)result;
21398   return jresult;
21399 }
21400
21401
21402 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_DownCast(void * jarg1) {
21403   void * jresult ;
21404   Dali::BaseHandle arg1 ;
21405   Dali::BaseHandle *argp1 ;
21406   Dali::Texture result;
21407
21408   argp1 = (Dali::BaseHandle *)jarg1;
21409   if (!argp1) {
21410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21411     return 0;
21412   }
21413   arg1 = *argp1;
21414   {
21415     try {
21416       result = Dali::Texture::DownCast(arg1);
21417     } catch (std::out_of_range& e) {
21418       {
21419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21420       };
21421     } catch (std::exception& e) {
21422       {
21423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21424       };
21425     } catch (...) {
21426       {
21427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21428       };
21429     }
21430   }
21431   jresult = new Dali::Texture((const Dali::Texture &)result);
21432   return jresult;
21433 }
21434
21435
21436 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Texture_Assign(void * jarg1, void * jarg2) {
21437   void * jresult ;
21438   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21439   Dali::Texture *arg2 = 0 ;
21440   Dali::Texture *result = 0 ;
21441
21442   arg1 = (Dali::Texture *)jarg1;
21443   arg2 = (Dali::Texture *)jarg2;
21444   if (!arg2) {
21445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21446     return 0;
21447   }
21448   {
21449     try {
21450       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21451     } catch (std::out_of_range& e) {
21452       {
21453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21454       };
21455     } catch (std::exception& e) {
21456       {
21457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (...) {
21460       {
21461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21462       };
21463     }
21464   }
21465   jresult = (void *)result;
21466   return jresult;
21467 }
21468
21469
21470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21471   unsigned int jresult ;
21472   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21473   Dali::PixelData arg2 ;
21474   Dali::PixelData *argp2 ;
21475   bool result;
21476
21477   arg1 = (Dali::Texture *)jarg1;
21478   argp2 = (Dali::PixelData *)jarg2;
21479   if (!argp2) {
21480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21481     return 0;
21482   }
21483   arg2 = *argp2;
21484   {
21485     try {
21486       result = (bool)(arg1)->Upload(arg2);
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (...) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21498       };
21499     }
21500   }
21501   jresult = result;
21502   return jresult;
21503 }
21504
21505
21506 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) {
21507   unsigned int jresult ;
21508   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21509   Dali::PixelData arg2 ;
21510   unsigned int arg3 ;
21511   unsigned int arg4 ;
21512   unsigned int arg5 ;
21513   unsigned int arg6 ;
21514   unsigned int arg7 ;
21515   unsigned int arg8 ;
21516   Dali::PixelData *argp2 ;
21517   bool result;
21518
21519   arg1 = (Dali::Texture *)jarg1;
21520   argp2 = (Dali::PixelData *)jarg2;
21521   if (!argp2) {
21522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21523     return 0;
21524   }
21525   arg2 = *argp2;
21526   arg3 = (unsigned int)jarg3;
21527   arg4 = (unsigned int)jarg4;
21528   arg5 = (unsigned int)jarg5;
21529   arg6 = (unsigned int)jarg6;
21530   arg7 = (unsigned int)jarg7;
21531   arg8 = (unsigned int)jarg8;
21532   {
21533     try {
21534       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21535     } catch (std::out_of_range& e) {
21536       {
21537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21538       };
21539     } catch (std::exception& e) {
21540       {
21541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21542       };
21543     } catch (...) {
21544       {
21545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21546       };
21547     }
21548   }
21549   jresult = result;
21550   return jresult;
21551 }
21552
21553
21554 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Texture_GenerateMipmaps(void * jarg1) {
21555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21556
21557   arg1 = (Dali::Texture *)jarg1;
21558   {
21559     try {
21560       (arg1)->GenerateMipmaps();
21561     } catch (std::out_of_range& e) {
21562       {
21563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21564       };
21565     } catch (std::exception& e) {
21566       {
21567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21568       };
21569     } catch (...) {
21570       {
21571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21572       };
21573     }
21574   }
21575 }
21576
21577
21578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_GetWidth(void * jarg1) {
21579   unsigned int jresult ;
21580   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21581   unsigned int result;
21582
21583   arg1 = (Dali::Texture *)jarg1;
21584   {
21585     try {
21586       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21587     } catch (std::out_of_range& e) {
21588       {
21589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21590       };
21591     } catch (std::exception& e) {
21592       {
21593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21594       };
21595     } catch (...) {
21596       {
21597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21598       };
21599     }
21600   }
21601   jresult = result;
21602   return jresult;
21603 }
21604
21605
21606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Texture_GetHeight(void * jarg1) {
21607   unsigned int jresult ;
21608   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21609   unsigned int result;
21610
21611   arg1 = (Dali::Texture *)jarg1;
21612   {
21613     try {
21614       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21615     } catch (std::out_of_range& e) {
21616       {
21617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21618       };
21619     } catch (std::exception& e) {
21620       {
21621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21622       };
21623     } catch (...) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21626       };
21627     }
21628   }
21629   jresult = result;
21630   return jresult;
21631 }
21632
21633
21634 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_New() {
21635   void * jresult ;
21636   Dali::Sampler result;
21637
21638   {
21639     try {
21640       result = Dali::Sampler::New();
21641     } catch (std::out_of_range& e) {
21642       {
21643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21644       };
21645     } catch (std::exception& e) {
21646       {
21647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21648       };
21649     } catch (...) {
21650       {
21651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21652       };
21653     }
21654   }
21655   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21656   return jresult;
21657 }
21658
21659
21660 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Sampler__SWIG_0() {
21661   void * jresult ;
21662   Dali::Sampler *result = 0 ;
21663
21664   {
21665     try {
21666       result = (Dali::Sampler *)new Dali::Sampler();
21667     } catch (std::out_of_range& e) {
21668       {
21669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21670       };
21671     } catch (std::exception& e) {
21672       {
21673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21674       };
21675     } catch (...) {
21676       {
21677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21678       };
21679     }
21680   }
21681   jresult = (void *)result;
21682   return jresult;
21683 }
21684
21685
21686 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Sampler(void * jarg1) {
21687   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21688
21689   arg1 = (Dali::Sampler *)jarg1;
21690   {
21691     try {
21692       delete arg1;
21693     } catch (std::out_of_range& e) {
21694       {
21695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21696       };
21697     } catch (std::exception& e) {
21698       {
21699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21700       };
21701     } catch (...) {
21702       {
21703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21704       };
21705     }
21706   }
21707 }
21708
21709
21710 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Sampler__SWIG_1(void * jarg1) {
21711   void * jresult ;
21712   Dali::Sampler *arg1 = 0 ;
21713   Dali::Sampler *result = 0 ;
21714
21715   arg1 = (Dali::Sampler *)jarg1;
21716   if (!arg1) {
21717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21718     return 0;
21719   }
21720   {
21721     try {
21722       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21723     } catch (std::out_of_range& e) {
21724       {
21725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21726       };
21727     } catch (std::exception& e) {
21728       {
21729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21730       };
21731     } catch (...) {
21732       {
21733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21734       };
21735     }
21736   }
21737   jresult = (void *)result;
21738   return jresult;
21739 }
21740
21741
21742 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_DownCast(void * jarg1) {
21743   void * jresult ;
21744   Dali::BaseHandle arg1 ;
21745   Dali::BaseHandle *argp1 ;
21746   Dali::Sampler result;
21747
21748   argp1 = (Dali::BaseHandle *)jarg1;
21749   if (!argp1) {
21750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21751     return 0;
21752   }
21753   arg1 = *argp1;
21754   {
21755     try {
21756       result = Dali::Sampler::DownCast(arg1);
21757     } catch (std::out_of_range& e) {
21758       {
21759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (std::exception& e) {
21762       {
21763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21764       };
21765     } catch (...) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21768       };
21769     }
21770   }
21771   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21772   return jresult;
21773 }
21774
21775
21776 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Sampler_Assign(void * jarg1, void * jarg2) {
21777   void * jresult ;
21778   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21779   Dali::Sampler *arg2 = 0 ;
21780   Dali::Sampler *result = 0 ;
21781
21782   arg1 = (Dali::Sampler *)jarg1;
21783   arg2 = (Dali::Sampler *)jarg2;
21784   if (!arg2) {
21785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21786     return 0;
21787   }
21788   {
21789     try {
21790       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21791     } catch (std::out_of_range& e) {
21792       {
21793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21794       };
21795     } catch (std::exception& e) {
21796       {
21797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (...) {
21800       {
21801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21802       };
21803     }
21804   }
21805   jresult = (void *)result;
21806   return jresult;
21807 }
21808
21809
21810 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21811   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21812   Dali::FilterMode::Type arg2 ;
21813   Dali::FilterMode::Type arg3 ;
21814
21815   arg1 = (Dali::Sampler *)jarg1;
21816   arg2 = (Dali::FilterMode::Type)jarg2;
21817   arg3 = (Dali::FilterMode::Type)jarg3;
21818   {
21819     try {
21820       (arg1)->SetFilterMode(arg2,arg3);
21821     } catch (std::out_of_range& e) {
21822       {
21823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21824       };
21825     } catch (std::exception& e) {
21826       {
21827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21828       };
21829     } catch (...) {
21830       {
21831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21832       };
21833     }
21834   }
21835 }
21836
21837
21838 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21839   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21840   Dali::WrapMode::Type arg2 ;
21841   Dali::WrapMode::Type arg3 ;
21842
21843   arg1 = (Dali::Sampler *)jarg1;
21844   arg2 = (Dali::WrapMode::Type)jarg2;
21845   arg3 = (Dali::WrapMode::Type)jarg3;
21846   {
21847     try {
21848       (arg1)->SetWrapMode(arg2,arg3);
21849     } catch (std::out_of_range& e) {
21850       {
21851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21852       };
21853     } catch (std::exception& e) {
21854       {
21855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21856       };
21857     } catch (...) {
21858       {
21859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21860       };
21861     }
21862   }
21863 }
21864
21865
21866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21867   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21868   Dali::WrapMode::Type arg2 ;
21869   Dali::WrapMode::Type arg3 ;
21870   Dali::WrapMode::Type arg4 ;
21871
21872   arg1 = (Dali::Sampler *)jarg1;
21873   arg2 = (Dali::WrapMode::Type)jarg2;
21874   arg3 = (Dali::WrapMode::Type)jarg3;
21875   arg4 = (Dali::WrapMode::Type)jarg4;
21876   {
21877     try {
21878       (arg1)->SetWrapMode(arg2,arg3,arg4);
21879     } catch (std::out_of_range& e) {
21880       {
21881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21882       };
21883     } catch (std::exception& e) {
21884       {
21885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21890       };
21891     }
21892   }
21893 }
21894
21895
21896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_New() {
21897   void * jresult ;
21898   Dali::TextureSet result;
21899
21900   {
21901     try {
21902       result = Dali::TextureSet::New();
21903     } catch (std::out_of_range& e) {
21904       {
21905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21906       };
21907     } catch (std::exception& e) {
21908       {
21909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (...) {
21912       {
21913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21914       };
21915     }
21916   }
21917   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
21918   return jresult;
21919 }
21920
21921
21922 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextureSet__SWIG_0() {
21923   void * jresult ;
21924   Dali::TextureSet *result = 0 ;
21925
21926   {
21927     try {
21928       result = (Dali::TextureSet *)new Dali::TextureSet();
21929     } catch (std::out_of_range& e) {
21930       {
21931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21932       };
21933     } catch (std::exception& e) {
21934       {
21935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21936       };
21937     } catch (...) {
21938       {
21939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21940       };
21941     }
21942   }
21943   jresult = (void *)result;
21944   return jresult;
21945 }
21946
21947
21948 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextureSet(void * jarg1) {
21949   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
21950
21951   arg1 = (Dali::TextureSet *)jarg1;
21952   {
21953     try {
21954       delete arg1;
21955     } catch (std::out_of_range& e) {
21956       {
21957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21958       };
21959     } catch (std::exception& e) {
21960       {
21961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21962       };
21963     } catch (...) {
21964       {
21965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21966       };
21967     }
21968   }
21969 }
21970
21971
21972 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextureSet__SWIG_1(void * jarg1) {
21973   void * jresult ;
21974   Dali::TextureSet *arg1 = 0 ;
21975   Dali::TextureSet *result = 0 ;
21976
21977   arg1 = (Dali::TextureSet *)jarg1;
21978   if (!arg1) {
21979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
21980     return 0;
21981   }
21982   {
21983     try {
21984       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
21985     } catch (std::out_of_range& e) {
21986       {
21987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21988       };
21989     } catch (std::exception& e) {
21990       {
21991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21992       };
21993     } catch (...) {
21994       {
21995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21996       };
21997     }
21998   }
21999   jresult = (void *)result;
22000   return jresult;
22001 }
22002
22003
22004 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_DownCast(void * jarg1) {
22005   void * jresult ;
22006   Dali::BaseHandle arg1 ;
22007   Dali::BaseHandle *argp1 ;
22008   Dali::TextureSet result;
22009
22010   argp1 = (Dali::BaseHandle *)jarg1;
22011   if (!argp1) {
22012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22013     return 0;
22014   }
22015   arg1 = *argp1;
22016   {
22017     try {
22018       result = Dali::TextureSet::DownCast(arg1);
22019     } catch (std::out_of_range& e) {
22020       {
22021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (std::exception& e) {
22024       {
22025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22026       };
22027     } catch (...) {
22028       {
22029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22030       };
22031     }
22032   }
22033   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22034   return jresult;
22035 }
22036
22037
22038 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_Assign(void * jarg1, void * jarg2) {
22039   void * jresult ;
22040   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22041   Dali::TextureSet *arg2 = 0 ;
22042   Dali::TextureSet *result = 0 ;
22043
22044   arg1 = (Dali::TextureSet *)jarg1;
22045   arg2 = (Dali::TextureSet *)jarg2;
22046   if (!arg2) {
22047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22048     return 0;
22049   }
22050   {
22051     try {
22052       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22053     } catch (std::out_of_range& e) {
22054       {
22055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22056       };
22057     } catch (std::exception& e) {
22058       {
22059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (...) {
22062       {
22063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22064       };
22065     }
22066   }
22067   jresult = (void *)result;
22068   return jresult;
22069 }
22070
22071
22072 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22073   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22074   size_t arg2 ;
22075   Dali::Texture arg3 ;
22076   Dali::Texture *argp3 ;
22077
22078   arg1 = (Dali::TextureSet *)jarg1;
22079   arg2 = (size_t)jarg2;
22080   argp3 = (Dali::Texture *)jarg3;
22081   if (!argp3) {
22082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22083     return ;
22084   }
22085   arg3 = *argp3;
22086   {
22087     try {
22088       (arg1)->SetTexture(arg2,arg3);
22089     } catch (std::out_of_range& e) {
22090       {
22091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22092       };
22093     } catch (std::exception& e) {
22094       {
22095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22096       };
22097     } catch (...) {
22098       {
22099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22100       };
22101     }
22102   }
22103 }
22104
22105
22106 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22107   void * jresult ;
22108   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22109   size_t arg2 ;
22110   Dali::Texture result;
22111
22112   arg1 = (Dali::TextureSet *)jarg1;
22113   arg2 = (size_t)jarg2;
22114   {
22115     try {
22116       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (...) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22128       };
22129     }
22130   }
22131   jresult = new Dali::Texture((const Dali::Texture &)result);
22132   return jresult;
22133 }
22134
22135
22136 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22137   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22138   size_t arg2 ;
22139   Dali::Sampler arg3 ;
22140   Dali::Sampler *argp3 ;
22141
22142   arg1 = (Dali::TextureSet *)jarg1;
22143   arg2 = (size_t)jarg2;
22144   argp3 = (Dali::Sampler *)jarg3;
22145   if (!argp3) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22147     return ;
22148   }
22149   arg3 = *argp3;
22150   {
22151     try {
22152       (arg1)->SetSampler(arg2,arg3);
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (...) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22164       };
22165     }
22166   }
22167 }
22168
22169
22170 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22171   void * jresult ;
22172   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22173   size_t arg2 ;
22174   Dali::Sampler result;
22175
22176   arg1 = (Dali::TextureSet *)jarg1;
22177   arg2 = (size_t)jarg2;
22178   {
22179     try {
22180       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22181     } catch (std::out_of_range& e) {
22182       {
22183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22184       };
22185     } catch (std::exception& e) {
22186       {
22187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22188       };
22189     } catch (...) {
22190       {
22191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22192       };
22193     }
22194   }
22195   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22196   return jresult;
22197 }
22198
22199
22200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextureSet_GetTextureCount(void * jarg1) {
22201   unsigned long jresult ;
22202   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22203   size_t result;
22204
22205   arg1 = (Dali::TextureSet *)jarg1;
22206   {
22207     try {
22208       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22216       };
22217     } catch (...) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22220       };
22221     }
22222   }
22223   jresult = (unsigned long)result;
22224   return jresult;
22225 }
22226
22227
22228 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_New(void * jarg1) {
22229   void * jresult ;
22230   Dali::Property::Map *arg1 = 0 ;
22231   Dali::PropertyBuffer result;
22232
22233   arg1 = (Dali::Property::Map *)jarg1;
22234   if (!arg1) {
22235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22236     return 0;
22237   }
22238   {
22239     try {
22240       result = Dali::PropertyBuffer::New(*arg1);
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22248       };
22249     } catch (...) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22252       };
22253     }
22254   }
22255   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22256   return jresult;
22257 }
22258
22259
22260 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyBuffer__SWIG_0() {
22261   void * jresult ;
22262   Dali::PropertyBuffer *result = 0 ;
22263
22264   {
22265     try {
22266       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22267     } catch (std::out_of_range& e) {
22268       {
22269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22270       };
22271     } catch (std::exception& e) {
22272       {
22273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22274       };
22275     } catch (...) {
22276       {
22277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22278       };
22279     }
22280   }
22281   jresult = (void *)result;
22282   return jresult;
22283 }
22284
22285
22286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyBuffer(void * jarg1) {
22287   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22288
22289   arg1 = (Dali::PropertyBuffer *)jarg1;
22290   {
22291     try {
22292       delete arg1;
22293     } catch (std::out_of_range& e) {
22294       {
22295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22296       };
22297     } catch (std::exception& e) {
22298       {
22299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22300       };
22301     } catch (...) {
22302       {
22303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22304       };
22305     }
22306   }
22307 }
22308
22309
22310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyBuffer__SWIG_1(void * jarg1) {
22311   void * jresult ;
22312   Dali::PropertyBuffer *arg1 = 0 ;
22313   Dali::PropertyBuffer *result = 0 ;
22314
22315   arg1 = (Dali::PropertyBuffer *)jarg1;
22316   if (!arg1) {
22317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22318     return 0;
22319   }
22320   {
22321     try {
22322       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22323     } catch (std::out_of_range& e) {
22324       {
22325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22326       };
22327     } catch (std::exception& e) {
22328       {
22329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22330       };
22331     } catch (...) {
22332       {
22333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22334       };
22335     }
22336   }
22337   jresult = (void *)result;
22338   return jresult;
22339 }
22340
22341
22342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_DownCast(void * jarg1) {
22343   void * jresult ;
22344   Dali::BaseHandle arg1 ;
22345   Dali::BaseHandle *argp1 ;
22346   Dali::PropertyBuffer result;
22347
22348   argp1 = (Dali::BaseHandle *)jarg1;
22349   if (!argp1) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22351     return 0;
22352   }
22353   arg1 = *argp1;
22354   {
22355     try {
22356       result = Dali::PropertyBuffer::DownCast(arg1);
22357     } catch (std::out_of_range& e) {
22358       {
22359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22360       };
22361     } catch (std::exception& e) {
22362       {
22363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22364       };
22365     } catch (...) {
22366       {
22367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22368       };
22369     }
22370   }
22371   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22372   return jresult;
22373 }
22374
22375
22376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22377   void * jresult ;
22378   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22379   Dali::PropertyBuffer *arg2 = 0 ;
22380   Dali::PropertyBuffer *result = 0 ;
22381
22382   arg1 = (Dali::PropertyBuffer *)jarg1;
22383   arg2 = (Dali::PropertyBuffer *)jarg2;
22384   if (!arg2) {
22385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22386     return 0;
22387   }
22388   {
22389     try {
22390       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22398       };
22399     } catch (...) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22402       };
22403     }
22404   }
22405   jresult = (void *)result;
22406   return jresult;
22407 }
22408
22409
22410 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22411   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22412   void *arg2 = (void *) 0 ;
22413   std::size_t arg3 ;
22414
22415   arg1 = (Dali::PropertyBuffer *)jarg1;
22416   arg2 = jarg2;
22417   arg3 = (std::size_t)jarg3;
22418   {
22419     try {
22420       (arg1)->SetData((void const *)arg2,arg3);
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22432       };
22433     }
22434   }
22435 }
22436
22437
22438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyBuffer_GetSize(void * jarg1) {
22439   unsigned long jresult ;
22440   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22441   std::size_t result;
22442
22443   arg1 = (Dali::PropertyBuffer *)jarg1;
22444   {
22445     try {
22446       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22447     } catch (std::out_of_range& e) {
22448       {
22449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22450       };
22451     } catch (std::exception& e) {
22452       {
22453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (...) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22458       };
22459     }
22460   }
22461   jresult = (unsigned long)result;
22462   return jresult;
22463 }
22464
22465
22466 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_New() {
22467   void * jresult ;
22468   Dali::Geometry result;
22469
22470   {
22471     try {
22472       result = Dali::Geometry::New();
22473     } catch (std::out_of_range& e) {
22474       {
22475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22476       };
22477     } catch (std::exception& e) {
22478       {
22479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22480       };
22481     } catch (...) {
22482       {
22483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22484       };
22485     }
22486   }
22487   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22488   return jresult;
22489 }
22490
22491
22492 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Geometry__SWIG_0() {
22493   void * jresult ;
22494   Dali::Geometry *result = 0 ;
22495
22496   {
22497     try {
22498       result = (Dali::Geometry *)new Dali::Geometry();
22499     } catch (std::out_of_range& e) {
22500       {
22501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22502       };
22503     } catch (std::exception& e) {
22504       {
22505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22506       };
22507     } catch (...) {
22508       {
22509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22510       };
22511     }
22512   }
22513   jresult = (void *)result;
22514   return jresult;
22515 }
22516
22517
22518 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Geometry(void * jarg1) {
22519   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22520
22521   arg1 = (Dali::Geometry *)jarg1;
22522   {
22523     try {
22524       delete arg1;
22525     } catch (std::out_of_range& e) {
22526       {
22527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22528       };
22529     } catch (std::exception& e) {
22530       {
22531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22532       };
22533     } catch (...) {
22534       {
22535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22536       };
22537     }
22538   }
22539 }
22540
22541
22542 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Geometry__SWIG_1(void * jarg1) {
22543   void * jresult ;
22544   Dali::Geometry *arg1 = 0 ;
22545   Dali::Geometry *result = 0 ;
22546
22547   arg1 = (Dali::Geometry *)jarg1;
22548   if (!arg1) {
22549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22550     return 0;
22551   }
22552   {
22553     try {
22554       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22555     } catch (std::out_of_range& e) {
22556       {
22557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22558       };
22559     } catch (std::exception& e) {
22560       {
22561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22562       };
22563     } catch (...) {
22564       {
22565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22566       };
22567     }
22568   }
22569   jresult = (void *)result;
22570   return jresult;
22571 }
22572
22573
22574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_DownCast(void * jarg1) {
22575   void * jresult ;
22576   Dali::BaseHandle arg1 ;
22577   Dali::BaseHandle *argp1 ;
22578   Dali::Geometry result;
22579
22580   argp1 = (Dali::BaseHandle *)jarg1;
22581   if (!argp1) {
22582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22583     return 0;
22584   }
22585   arg1 = *argp1;
22586   {
22587     try {
22588       result = Dali::Geometry::DownCast(arg1);
22589     } catch (std::out_of_range& e) {
22590       {
22591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (std::exception& e) {
22594       {
22595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22596       };
22597     } catch (...) {
22598       {
22599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22600       };
22601     }
22602   }
22603   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22604   return jresult;
22605 }
22606
22607
22608 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Geometry_Assign(void * jarg1, void * jarg2) {
22609   void * jresult ;
22610   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22611   Dali::Geometry *arg2 = 0 ;
22612   Dali::Geometry *result = 0 ;
22613
22614   arg1 = (Dali::Geometry *)jarg1;
22615   arg2 = (Dali::Geometry *)jarg2;
22616   if (!arg2) {
22617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22618     return 0;
22619   }
22620   {
22621     try {
22622       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22623     } catch (std::out_of_range& e) {
22624       {
22625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22626       };
22627     } catch (std::exception& e) {
22628       {
22629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22634       };
22635     }
22636   }
22637   jresult = (void *)result;
22638   return jresult;
22639 }
22640
22641
22642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22643   unsigned long jresult ;
22644   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22645   Dali::PropertyBuffer *arg2 = 0 ;
22646   std::size_t result;
22647
22648   arg1 = (Dali::Geometry *)jarg1;
22649   arg2 = (Dali::PropertyBuffer *)jarg2;
22650   if (!arg2) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22652     return 0;
22653   }
22654   {
22655     try {
22656       result = (arg1)->AddVertexBuffer(*arg2);
22657     } catch (std::out_of_range& e) {
22658       {
22659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22660       };
22661     } catch (std::exception& e) {
22662       {
22663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (...) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22668       };
22669     }
22670   }
22671   jresult = (unsigned long)result;
22672   return jresult;
22673 }
22674
22675
22676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22677   unsigned long jresult ;
22678   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22679   std::size_t result;
22680
22681   arg1 = (Dali::Geometry *)jarg1;
22682   {
22683     try {
22684       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (...) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22696       };
22697     }
22698   }
22699   jresult = (unsigned long)result;
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22705   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22706   std::size_t arg2 ;
22707
22708   arg1 = (Dali::Geometry *)jarg1;
22709   arg2 = (std::size_t)jarg2;
22710   {
22711     try {
22712       (arg1)->RemoveVertexBuffer(arg2);
22713     } catch (std::out_of_range& e) {
22714       {
22715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22716       };
22717     } catch (std::exception& e) {
22718       {
22719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22720       };
22721     } catch (...) {
22722       {
22723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22724       };
22725     }
22726   }
22727 }
22728
22729
22730 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22731   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22732   unsigned short *arg2 = (unsigned short *) 0 ;
22733   size_t arg3 ;
22734
22735   arg1 = (Dali::Geometry *)jarg1;
22736   arg2 = jarg2;
22737   arg3 = (size_t)jarg3;
22738   {
22739     try {
22740       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22741     } catch (std::out_of_range& e) {
22742       {
22743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22744       };
22745     } catch (std::exception& e) {
22746       {
22747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22748       };
22749     } catch (...) {
22750       {
22751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22752       };
22753     }
22754   }
22755
22756
22757 }
22758
22759
22760 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Geometry_SetType(void * jarg1, int jarg2) {
22761   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22762   Dali::Geometry::Type arg2 ;
22763
22764   arg1 = (Dali::Geometry *)jarg1;
22765   arg2 = (Dali::Geometry::Type)jarg2;
22766   {
22767     try {
22768       (arg1)->SetType(arg2);
22769     } catch (std::out_of_range& e) {
22770       {
22771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22772       };
22773     } catch (std::exception& e) {
22774       {
22775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22776       };
22777     } catch (...) {
22778       {
22779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22780       };
22781     }
22782   }
22783 }
22784
22785
22786 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Geometry_GetType(void * jarg1) {
22787   int jresult ;
22788   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22789   Dali::Geometry::Type result;
22790
22791   arg1 = (Dali::Geometry *)jarg1;
22792   {
22793     try {
22794       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22795     } catch (std::out_of_range& e) {
22796       {
22797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22798       };
22799     } catch (std::exception& e) {
22800       {
22801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22802       };
22803     } catch (...) {
22804       {
22805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22806       };
22807     }
22808   }
22809   jresult = (int)result;
22810   return jresult;
22811 }
22812
22813
22814 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader_Hint() {
22815   void * jresult ;
22816   Dali::Shader::Hint *result = 0 ;
22817
22818   {
22819     try {
22820       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22821     } catch (std::out_of_range& e) {
22822       {
22823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22824       };
22825     } catch (std::exception& e) {
22826       {
22827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (...) {
22830       {
22831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22832       };
22833     }
22834   }
22835   jresult = (void *)result;
22836   return jresult;
22837 }
22838
22839
22840 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader_Hint(void * jarg1) {
22841   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22842
22843   arg1 = (Dali::Shader::Hint *)jarg1;
22844   {
22845     try {
22846       delete arg1;
22847     } catch (std::out_of_range& e) {
22848       {
22849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22850       };
22851     } catch (std::exception& e) {
22852       {
22853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22854       };
22855     } catch (...) {
22856       {
22857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22858       };
22859     }
22860   }
22861 }
22862
22863
22864 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Shader_Property_PROGRAM_get() {
22865   int jresult ;
22866   int result;
22867
22868   result = (int)Dali::Shader::Property::PROGRAM;
22869   jresult = (int)result;
22870   return jresult;
22871 }
22872
22873
22874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader_Property() {
22875   void * jresult ;
22876   Dali::Shader::Property *result = 0 ;
22877
22878   {
22879     try {
22880       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22888       };
22889     } catch (...) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22892       };
22893     }
22894   }
22895   jresult = (void *)result;
22896   return jresult;
22897 }
22898
22899
22900 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader_Property(void * jarg1) {
22901   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
22902
22903   arg1 = (Dali::Shader::Property *)jarg1;
22904   {
22905     try {
22906       delete arg1;
22907     } catch (std::out_of_range& e) {
22908       {
22909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22910       };
22911     } catch (std::exception& e) {
22912       {
22913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22914       };
22915     } catch (...) {
22916       {
22917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22918       };
22919     }
22920   }
22921 }
22922
22923
22924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
22925   void * jresult ;
22926   std::string *arg1 = 0 ;
22927   std::string *arg2 = 0 ;
22928   Dali::Shader::Hint::Value arg3 ;
22929   Dali::Shader result;
22930
22931   if (!jarg1) {
22932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22933     return 0;
22934   }
22935   std::string arg1_str(jarg1);
22936   arg1 = &arg1_str;
22937   if (!jarg2) {
22938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22939     return 0;
22940   }
22941   std::string arg2_str(jarg2);
22942   arg2 = &arg2_str;
22943   arg3 = (Dali::Shader::Hint::Value)jarg3;
22944   {
22945     try {
22946       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
22947     } catch (std::out_of_range& e) {
22948       {
22949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22950       };
22951     } catch (std::exception& e) {
22952       {
22953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22954       };
22955     } catch (...) {
22956       {
22957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22958       };
22959     }
22960   }
22961   jresult = new Dali::Shader((const Dali::Shader &)result);
22962
22963   //argout typemap for const std::string&
22964
22965
22966   //argout typemap for const std::string&
22967
22968   return jresult;
22969 }
22970
22971
22972 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
22973   void * jresult ;
22974   std::string *arg1 = 0 ;
22975   std::string *arg2 = 0 ;
22976   Dali::Shader result;
22977
22978   if (!jarg1) {
22979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22980     return 0;
22981   }
22982   std::string arg1_str(jarg1);
22983   arg1 = &arg1_str;
22984   if (!jarg2) {
22985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22986     return 0;
22987   }
22988   std::string arg2_str(jarg2);
22989   arg2 = &arg2_str;
22990   {
22991     try {
22992       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
22993     } catch (std::out_of_range& e) {
22994       {
22995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22996       };
22997     } catch (std::exception& e) {
22998       {
22999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23000       };
23001     } catch (...) {
23002       {
23003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23004       };
23005     }
23006   }
23007   jresult = new Dali::Shader((const Dali::Shader &)result);
23008
23009   //argout typemap for const std::string&
23010
23011
23012   //argout typemap for const std::string&
23013
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader__SWIG_0() {
23019   void * jresult ;
23020   Dali::Shader *result = 0 ;
23021
23022   {
23023     try {
23024       result = (Dali::Shader *)new Dali::Shader();
23025     } catch (std::out_of_range& e) {
23026       {
23027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23028       };
23029     } catch (std::exception& e) {
23030       {
23031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23032       };
23033     } catch (...) {
23034       {
23035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23036       };
23037     }
23038   }
23039   jresult = (void *)result;
23040   return jresult;
23041 }
23042
23043
23044 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Shader(void * jarg1) {
23045   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23046
23047   arg1 = (Dali::Shader *)jarg1;
23048   {
23049     try {
23050       delete arg1;
23051     } catch (std::out_of_range& e) {
23052       {
23053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23054       };
23055     } catch (std::exception& e) {
23056       {
23057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23058       };
23059     } catch (...) {
23060       {
23061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23062       };
23063     }
23064   }
23065 }
23066
23067
23068 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Shader__SWIG_1(void * jarg1) {
23069   void * jresult ;
23070   Dali::Shader *arg1 = 0 ;
23071   Dali::Shader *result = 0 ;
23072
23073   arg1 = (Dali::Shader *)jarg1;
23074   if (!arg1) {
23075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23076     return 0;
23077   }
23078   {
23079     try {
23080       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23081     } catch (std::out_of_range& e) {
23082       {
23083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23084       };
23085     } catch (std::exception& e) {
23086       {
23087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23088       };
23089     } catch (...) {
23090       {
23091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23092       };
23093     }
23094   }
23095   jresult = (void *)result;
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_DownCast(void * jarg1) {
23101   void * jresult ;
23102   Dali::BaseHandle arg1 ;
23103   Dali::BaseHandle *argp1 ;
23104   Dali::Shader result;
23105
23106   argp1 = (Dali::BaseHandle *)jarg1;
23107   if (!argp1) {
23108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23109     return 0;
23110   }
23111   arg1 = *argp1;
23112   {
23113     try {
23114       result = Dali::Shader::DownCast(arg1);
23115     } catch (std::out_of_range& e) {
23116       {
23117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23118       };
23119     } catch (std::exception& e) {
23120       {
23121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23122       };
23123     } catch (...) {
23124       {
23125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23126       };
23127     }
23128   }
23129   jresult = new Dali::Shader((const Dali::Shader &)result);
23130   return jresult;
23131 }
23132
23133
23134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Shader_Assign(void * jarg1, void * jarg2) {
23135   void * jresult ;
23136   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23137   Dali::Shader *arg2 = 0 ;
23138   Dali::Shader *result = 0 ;
23139
23140   arg1 = (Dali::Shader *)jarg1;
23141   arg2 = (Dali::Shader *)jarg2;
23142   if (!arg2) {
23143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23144     return 0;
23145   }
23146   {
23147     try {
23148       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23149     } catch (std::out_of_range& e) {
23150       {
23151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23152       };
23153     } catch (std::exception& e) {
23154       {
23155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23156       };
23157     } catch (...) {
23158       {
23159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23160       };
23161     }
23162   }
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_INDEX_get() {
23169   int jresult ;
23170   int result;
23171
23172   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23173   jresult = (int)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_FACE_CULLING_MODE_get() {
23179   int jresult ;
23180   int result;
23181
23182   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23183   jresult = (int)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_MODE_get() {
23189   int jresult ;
23190   int result;
23191
23192   result = (int)Dali::Renderer::Property::BLEND_MODE;
23193   jresult = (int)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_EQUATION_RGB_get() {
23199   int jresult ;
23200   int result;
23201
23202   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23203   jresult = (int)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23209   int jresult ;
23210   int result;
23211
23212   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23213   jresult = (int)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23219   int jresult ;
23220   int result;
23221
23222   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23223   jresult = (int)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23229   int jresult ;
23230   int result;
23231
23232   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23233   jresult = (int)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23239   int jresult ;
23240   int result;
23241
23242   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23243   jresult = (int)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23249   int jresult ;
23250   int result;
23251
23252   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23253   jresult = (int)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_COLOR_get() {
23259   int jresult ;
23260   int result;
23261
23262   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23263   jresult = (int)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23269   int jresult ;
23270   int result;
23271
23272   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23273   jresult = (int)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_INDEX_RANGE_FIRST_get() {
23279   int jresult ;
23280   int result;
23281
23282   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23283   jresult = (int)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_INDEX_RANGE_COUNT_get() {
23289   int jresult ;
23290   int result;
23291
23292   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23293   jresult = (int)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_WRITE_MODE_get() {
23299   int jresult ;
23300   int result;
23301
23302   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23303   jresult = (int)result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_FUNCTION_get() {
23309   int jresult ;
23310   int result;
23311
23312   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23313   jresult = (int)result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_DEPTH_TEST_MODE_get() {
23319   int jresult ;
23320   int result;
23321
23322   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23323   jresult = (int)result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_RENDER_MODE_get() {
23329   int jresult ;
23330   int result;
23331
23332   result = (int)Dali::Renderer::Property::RENDER_MODE;
23333   jresult = (int)result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_get() {
23339   int jresult ;
23340   int result;
23341
23342   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23343   jresult = (int)result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23349   int jresult ;
23350   int result;
23351
23352   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23353   jresult = (int)result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23359   int jresult ;
23360   int result;
23361
23362   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23363   jresult = (int)result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_MASK_get() {
23369   int jresult ;
23370   int result;
23371
23372   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23373   jresult = (int)result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23379   int jresult ;
23380   int result;
23381
23382   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23383   jresult = (int)result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23389   int jresult ;
23390   int result;
23391
23392   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23399   int jresult ;
23400   int result;
23401
23402   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23403   jresult = (int)result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer_Property() {
23409   void * jresult ;
23410   Dali::Renderer::Property *result = 0 ;
23411
23412   {
23413     try {
23414       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23415     } catch (std::out_of_range& e) {
23416       {
23417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23418       };
23419     } catch (std::exception& e) {
23420       {
23421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23422       };
23423     } catch (...) {
23424       {
23425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23426       };
23427     }
23428   }
23429   jresult = (void *)result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Renderer_Property(void * jarg1) {
23435   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23436
23437   arg1 = (Dali::Renderer::Property *)jarg1;
23438   {
23439     try {
23440       delete arg1;
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23448       };
23449     } catch (...) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23452       };
23453     }
23454   }
23455 }
23456
23457
23458 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_New(void * jarg1, void * jarg2) {
23459   void * jresult ;
23460   Dali::Geometry *arg1 = 0 ;
23461   Dali::Shader *arg2 = 0 ;
23462   Dali::Renderer result;
23463
23464   arg1 = (Dali::Geometry *)jarg1;
23465   if (!arg1) {
23466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23467     return 0;
23468   }
23469   arg2 = (Dali::Shader *)jarg2;
23470   if (!arg2) {
23471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23472     return 0;
23473   }
23474   {
23475     try {
23476       result = Dali::Renderer::New(*arg1,*arg2);
23477     } catch (std::out_of_range& e) {
23478       {
23479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (std::exception& e) {
23482       {
23483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23484       };
23485     } catch (...) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23488       };
23489     }
23490   }
23491   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23492   return jresult;
23493 }
23494
23495
23496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer__SWIG_0() {
23497   void * jresult ;
23498   Dali::Renderer *result = 0 ;
23499
23500   {
23501     try {
23502       result = (Dali::Renderer *)new Dali::Renderer();
23503     } catch (std::out_of_range& e) {
23504       {
23505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23506       };
23507     } catch (std::exception& e) {
23508       {
23509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (...) {
23512       {
23513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23514       };
23515     }
23516   }
23517   jresult = (void *)result;
23518   return jresult;
23519 }
23520
23521
23522 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Renderer(void * jarg1) {
23523   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23524
23525   arg1 = (Dali::Renderer *)jarg1;
23526   {
23527     try {
23528       delete arg1;
23529     } catch (std::out_of_range& e) {
23530       {
23531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23532       };
23533     } catch (std::exception& e) {
23534       {
23535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23536       };
23537     } catch (...) {
23538       {
23539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23540       };
23541     }
23542   }
23543 }
23544
23545
23546 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Renderer__SWIG_1(void * jarg1) {
23547   void * jresult ;
23548   Dali::Renderer *arg1 = 0 ;
23549   Dali::Renderer *result = 0 ;
23550
23551   arg1 = (Dali::Renderer *)jarg1;
23552   if (!arg1) {
23553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23554     return 0;
23555   }
23556   {
23557     try {
23558       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23559     } catch (std::out_of_range& e) {
23560       {
23561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23562       };
23563     } catch (std::exception& e) {
23564       {
23565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23566       };
23567     } catch (...) {
23568       {
23569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23570       };
23571     }
23572   }
23573   jresult = (void *)result;
23574   return jresult;
23575 }
23576
23577
23578 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_DownCast(void * jarg1) {
23579   void * jresult ;
23580   Dali::BaseHandle arg1 ;
23581   Dali::BaseHandle *argp1 ;
23582   Dali::Renderer result;
23583
23584   argp1 = (Dali::BaseHandle *)jarg1;
23585   if (!argp1) {
23586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23587     return 0;
23588   }
23589   arg1 = *argp1;
23590   {
23591     try {
23592       result = Dali::Renderer::DownCast(arg1);
23593     } catch (std::out_of_range& e) {
23594       {
23595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23596       };
23597     } catch (std::exception& e) {
23598       {
23599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23600       };
23601     } catch (...) {
23602       {
23603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23604       };
23605     }
23606   }
23607   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23608   return jresult;
23609 }
23610
23611
23612 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_Assign(void * jarg1, void * jarg2) {
23613   void * jresult ;
23614   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23615   Dali::Renderer *arg2 = 0 ;
23616   Dali::Renderer *result = 0 ;
23617
23618   arg1 = (Dali::Renderer *)jarg1;
23619   arg2 = (Dali::Renderer *)jarg2;
23620   if (!arg2) {
23621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23622     return 0;
23623   }
23624   {
23625     try {
23626       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23627     } catch (std::out_of_range& e) {
23628       {
23629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23630       };
23631     } catch (std::exception& e) {
23632       {
23633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (...) {
23636       {
23637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23638       };
23639     }
23640   }
23641   jresult = (void *)result;
23642   return jresult;
23643 }
23644
23645
23646 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23647   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23648   Dali::Geometry *arg2 = 0 ;
23649
23650   arg1 = (Dali::Renderer *)jarg1;
23651   arg2 = (Dali::Geometry *)jarg2;
23652   if (!arg2) {
23653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23654     return ;
23655   }
23656   {
23657     try {
23658       (arg1)->SetGeometry(*arg2);
23659     } catch (std::out_of_range& e) {
23660       {
23661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23662       };
23663     } catch (std::exception& e) {
23664       {
23665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23666       };
23667     } catch (...) {
23668       {
23669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23670       };
23671     }
23672   }
23673 }
23674
23675
23676 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetGeometry(void * jarg1) {
23677   void * jresult ;
23678   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23679   Dali::Geometry result;
23680
23681   arg1 = (Dali::Renderer *)jarg1;
23682   {
23683     try {
23684       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23685     } catch (std::out_of_range& e) {
23686       {
23687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23688       };
23689     } catch (std::exception& e) {
23690       {
23691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23692       };
23693     } catch (...) {
23694       {
23695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23696       };
23697     }
23698   }
23699   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23700   return jresult;
23701 }
23702
23703
23704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23705   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23706   int arg2 ;
23707   int arg3 ;
23708
23709   arg1 = (Dali::Renderer *)jarg1;
23710   arg2 = (int)jarg2;
23711   arg3 = (int)jarg3;
23712   {
23713     try {
23714       (arg1)->SetIndexRange(arg2,arg3);
23715     } catch (std::out_of_range& e) {
23716       {
23717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23718       };
23719     } catch (std::exception& e) {
23720       {
23721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23726       };
23727     }
23728   }
23729 }
23730
23731
23732 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetTextures(void * jarg1, void * jarg2) {
23733   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23734   Dali::TextureSet *arg2 = 0 ;
23735
23736   arg1 = (Dali::Renderer *)jarg1;
23737   arg2 = (Dali::TextureSet *)jarg2;
23738   if (!arg2) {
23739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23740     return ;
23741   }
23742   {
23743     try {
23744       (arg1)->SetTextures(*arg2);
23745     } catch (std::out_of_range& e) {
23746       {
23747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23748       };
23749     } catch (std::exception& e) {
23750       {
23751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23752       };
23753     } catch (...) {
23754       {
23755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23756       };
23757     }
23758   }
23759 }
23760
23761
23762 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetTextures(void * jarg1) {
23763   void * jresult ;
23764   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23765   Dali::TextureSet result;
23766
23767   arg1 = (Dali::Renderer *)jarg1;
23768   {
23769     try {
23770       result = ((Dali::Renderer const *)arg1)->GetTextures();
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23782       };
23783     }
23784   }
23785   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Renderer_SetShader(void * jarg1, void * jarg2) {
23791   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23792   Dali::Shader *arg2 = 0 ;
23793
23794   arg1 = (Dali::Renderer *)jarg1;
23795   arg2 = (Dali::Shader *)jarg2;
23796   if (!arg2) {
23797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23798     return ;
23799   }
23800   {
23801     try {
23802       (arg1)->SetShader(*arg2);
23803     } catch (std::out_of_range& e) {
23804       {
23805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23806       };
23807     } catch (std::exception& e) {
23808       {
23809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23810       };
23811     } catch (...) {
23812       {
23813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23814       };
23815     }
23816   }
23817 }
23818
23819
23820 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Renderer_GetShader(void * jarg1) {
23821   void * jresult ;
23822   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23823   Dali::Shader result;
23824
23825   arg1 = (Dali::Renderer *)jarg1;
23826   {
23827     try {
23828       result = ((Dali::Renderer const *)arg1)->GetShader();
23829     } catch (std::out_of_range& e) {
23830       {
23831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23832       };
23833     } catch (std::exception& e) {
23834       {
23835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23836       };
23837     } catch (...) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23840       };
23841     }
23842   }
23843   jresult = new Dali::Shader((const Dali::Shader &)result);
23844   return jresult;
23845 }
23846
23847
23848 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer_Attachment() {
23849   void * jresult ;
23850   Dali::FrameBuffer::Attachment *result = 0 ;
23851
23852   {
23853     try {
23854       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23855     } catch (std::out_of_range& e) {
23856       {
23857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23858       };
23859     } catch (std::exception& e) {
23860       {
23861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23862       };
23863     } catch (...) {
23864       {
23865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23866       };
23867     }
23868   }
23869   jresult = (void *)result;
23870   return jresult;
23871 }
23872
23873
23874 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBuffer_Attachment(void * jarg1) {
23875   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23876
23877   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23878   {
23879     try {
23880       delete arg1;
23881     } catch (std::out_of_range& e) {
23882       {
23883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23884       };
23885     } catch (std::exception& e) {
23886       {
23887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23888       };
23889     } catch (...) {
23890       {
23891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23892       };
23893     }
23894   }
23895 }
23896
23897
23898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
23899   void * jresult ;
23900   unsigned int arg1 ;
23901   unsigned int arg2 ;
23902   unsigned int arg3 ;
23903   Dali::FrameBuffer result;
23904
23905   arg1 = (unsigned int)jarg1;
23906   arg2 = (unsigned int)jarg2;
23907   arg3 = (unsigned int)jarg3;
23908   {
23909     try {
23910       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
23911     } catch (std::out_of_range& e) {
23912       {
23913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23914       };
23915     } catch (std::exception& e) {
23916       {
23917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23918       };
23919     } catch (...) {
23920       {
23921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23922       };
23923     }
23924   }
23925   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
23926   return jresult;
23927 }
23928
23929
23930 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer__SWIG_0() {
23931   void * jresult ;
23932   Dali::FrameBuffer *result = 0 ;
23933
23934   {
23935     try {
23936       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23944       };
23945     } catch (...) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23948       };
23949     }
23950   }
23951   jresult = (void *)result;
23952   return jresult;
23953 }
23954
23955
23956 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBuffer(void * jarg1) {
23957   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
23958
23959   arg1 = (Dali::FrameBuffer *)jarg1;
23960   {
23961     try {
23962       delete arg1;
23963     } catch (std::out_of_range& e) {
23964       {
23965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23966       };
23967     } catch (std::exception& e) {
23968       {
23969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23970       };
23971     } catch (...) {
23972       {
23973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23974       };
23975     }
23976   }
23977 }
23978
23979
23980 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBuffer__SWIG_1(void * jarg1) {
23981   void * jresult ;
23982   Dali::FrameBuffer *arg1 = 0 ;
23983   Dali::FrameBuffer *result = 0 ;
23984
23985   arg1 = (Dali::FrameBuffer *)jarg1;
23986   if (!arg1) {
23987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
23988     return 0;
23989   }
23990   {
23991     try {
23992       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
23993     } catch (std::out_of_range& e) {
23994       {
23995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23996       };
23997     } catch (std::exception& e) {
23998       {
23999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24000       };
24001     } catch (...) {
24002       {
24003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24004       };
24005     }
24006   }
24007   jresult = (void *)result;
24008   return jresult;
24009 }
24010
24011
24012 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_DownCast(void * jarg1) {
24013   void * jresult ;
24014   Dali::BaseHandle arg1 ;
24015   Dali::BaseHandle *argp1 ;
24016   Dali::FrameBuffer result;
24017
24018   argp1 = (Dali::BaseHandle *)jarg1;
24019   if (!argp1) {
24020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24021     return 0;
24022   }
24023   arg1 = *argp1;
24024   {
24025     try {
24026       result = Dali::FrameBuffer::DownCast(arg1);
24027     } catch (std::out_of_range& e) {
24028       {
24029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24030       };
24031     } catch (std::exception& e) {
24032       {
24033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24034       };
24035     } catch (...) {
24036       {
24037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24038       };
24039     }
24040   }
24041   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24042   return jresult;
24043 }
24044
24045
24046 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24047   void * jresult ;
24048   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24049   Dali::FrameBuffer *arg2 = 0 ;
24050   Dali::FrameBuffer *result = 0 ;
24051
24052   arg1 = (Dali::FrameBuffer *)jarg1;
24053   arg2 = (Dali::FrameBuffer *)jarg2;
24054   if (!arg2) {
24055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24056     return 0;
24057   }
24058   {
24059     try {
24060       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24061     } catch (std::out_of_range& e) {
24062       {
24063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24064       };
24065     } catch (std::exception& e) {
24066       {
24067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24068       };
24069     } catch (...) {
24070       {
24071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24072       };
24073     }
24074   }
24075   jresult = (void *)result;
24076   return jresult;
24077 }
24078
24079
24080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24081   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24082   Dali::Texture *arg2 = 0 ;
24083
24084   arg1 = (Dali::FrameBuffer *)jarg1;
24085   arg2 = (Dali::Texture *)jarg2;
24086   if (!arg2) {
24087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24088     return ;
24089   }
24090   {
24091     try {
24092       (arg1)->AttachColorTexture(*arg2);
24093     } catch (std::out_of_range& e) {
24094       {
24095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24096       };
24097     } catch (std::exception& e) {
24098       {
24099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24104       };
24105     }
24106   }
24107 }
24108
24109
24110 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24111   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24112   Dali::Texture *arg2 = 0 ;
24113   unsigned int arg3 ;
24114   unsigned int arg4 ;
24115
24116   arg1 = (Dali::FrameBuffer *)jarg1;
24117   arg2 = (Dali::Texture *)jarg2;
24118   if (!arg2) {
24119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24120     return ;
24121   }
24122   arg3 = (unsigned int)jarg3;
24123   arg4 = (unsigned int)jarg4;
24124   {
24125     try {
24126       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24127     } catch (std::out_of_range& e) {
24128       {
24129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24130       };
24131     } catch (std::exception& e) {
24132       {
24133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24134       };
24135     } catch (...) {
24136       {
24137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24138       };
24139     }
24140   }
24141 }
24142
24143
24144 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBuffer_GetColorTexture(void * jarg1) {
24145   void * jresult ;
24146   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24147   Dali::Texture result;
24148
24149   arg1 = (Dali::FrameBuffer *)jarg1;
24150   {
24151     try {
24152       result = (arg1)->GetColorTexture();
24153     } catch (std::out_of_range& e) {
24154       {
24155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (std::exception& e) {
24158       {
24159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (...) {
24162       {
24163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24164       };
24165     }
24166   }
24167   jresult = new Dali::Texture((const Dali::Texture &)result);
24168   return jresult;
24169 }
24170
24171
24172 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskList__SWIG_0() {
24173   void * jresult ;
24174   Dali::RenderTaskList *result = 0 ;
24175
24176   {
24177     try {
24178       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24179     } catch (std::out_of_range& e) {
24180       {
24181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24182       };
24183     } catch (std::exception& e) {
24184       {
24185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24186       };
24187     } catch (...) {
24188       {
24189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24190       };
24191     }
24192   }
24193   jresult = (void *)result;
24194   return jresult;
24195 }
24196
24197
24198 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_DownCast(void * jarg1) {
24199   void * jresult ;
24200   Dali::BaseHandle arg1 ;
24201   Dali::BaseHandle *argp1 ;
24202   Dali::RenderTaskList result;
24203
24204   argp1 = (Dali::BaseHandle *)jarg1;
24205   if (!argp1) {
24206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24207     return 0;
24208   }
24209   arg1 = *argp1;
24210   {
24211     try {
24212       result = Dali::RenderTaskList::DownCast(arg1);
24213     } catch (std::out_of_range& e) {
24214       {
24215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24216       };
24217     } catch (std::exception& e) {
24218       {
24219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (...) {
24222       {
24223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24224       };
24225     }
24226   }
24227   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24228   return jresult;
24229 }
24230
24231
24232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTaskList(void * jarg1) {
24233   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24234
24235   arg1 = (Dali::RenderTaskList *)jarg1;
24236   {
24237     try {
24238       delete arg1;
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24250       };
24251     }
24252   }
24253 }
24254
24255
24256 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskList__SWIG_1(void * jarg1) {
24257   void * jresult ;
24258   Dali::RenderTaskList *arg1 = 0 ;
24259   Dali::RenderTaskList *result = 0 ;
24260
24261   arg1 = (Dali::RenderTaskList *)jarg1;
24262   if (!arg1) {
24263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24264     return 0;
24265   }
24266   {
24267     try {
24268       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24269     } catch (std::out_of_range& e) {
24270       {
24271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24272       };
24273     } catch (std::exception& e) {
24274       {
24275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (...) {
24278       {
24279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24280       };
24281     }
24282   }
24283   jresult = (void *)result;
24284   return jresult;
24285 }
24286
24287
24288 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24289   void * jresult ;
24290   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24291   Dali::RenderTaskList *arg2 = 0 ;
24292   Dali::RenderTaskList *result = 0 ;
24293
24294   arg1 = (Dali::RenderTaskList *)jarg1;
24295   arg2 = (Dali::RenderTaskList *)jarg2;
24296   if (!arg2) {
24297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24298     return 0;
24299   }
24300   {
24301     try {
24302       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24303     } catch (std::out_of_range& e) {
24304       {
24305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24306       };
24307     } catch (std::exception& e) {
24308       {
24309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24310       };
24311     } catch (...) {
24312       {
24313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24314       };
24315     }
24316   }
24317   jresult = (void *)result;
24318   return jresult;
24319 }
24320
24321
24322 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_CreateTask(void * jarg1) {
24323   void * jresult ;
24324   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24325   Dali::RenderTask result;
24326
24327   arg1 = (Dali::RenderTaskList *)jarg1;
24328   {
24329     try {
24330       result = (arg1)->CreateTask();
24331     } catch (std::out_of_range& e) {
24332       {
24333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24334       };
24335     } catch (std::exception& e) {
24336       {
24337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24338       };
24339     } catch (...) {
24340       {
24341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24342       };
24343     }
24344   }
24345   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24346   return jresult;
24347 }
24348
24349
24350 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24351   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24352   Dali::RenderTask arg2 ;
24353   Dali::RenderTask *argp2 ;
24354
24355   arg1 = (Dali::RenderTaskList *)jarg1;
24356   argp2 = (Dali::RenderTask *)jarg2;
24357   if (!argp2) {
24358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24359     return ;
24360   }
24361   arg2 = *argp2;
24362   {
24363     try {
24364       (arg1)->RemoveTask(arg2);
24365     } catch (std::out_of_range& e) {
24366       {
24367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24368       };
24369     } catch (std::exception& e) {
24370       {
24371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24372       };
24373     } catch (...) {
24374       {
24375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24376       };
24377     }
24378   }
24379 }
24380
24381
24382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTaskList_GetTaskCount(void * jarg1) {
24383   unsigned int jresult ;
24384   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24385   unsigned int result;
24386
24387   arg1 = (Dali::RenderTaskList *)jarg1;
24388   {
24389     try {
24390       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24391     } catch (std::out_of_range& e) {
24392       {
24393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (std::exception& e) {
24396       {
24397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405   jresult = result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24411   void * jresult ;
24412   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24413   unsigned int arg2 ;
24414   Dali::RenderTask result;
24415
24416   arg1 = (Dali::RenderTaskList *)jarg1;
24417   arg2 = (unsigned int)jarg2;
24418   {
24419     try {
24420       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24421     } catch (std::out_of_range& e) {
24422       {
24423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24424       };
24425     } catch (std::exception& e) {
24426       {
24427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24428       };
24429     } catch (...) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24432       };
24433     }
24434   }
24435   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24436   return jresult;
24437 }
24438
24439
24440 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_VIEWPORT_POSITION_get() {
24441   int jresult ;
24442   int result;
24443
24444   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24445   jresult = (int)result;
24446   return jresult;
24447 }
24448
24449
24450 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_VIEWPORT_SIZE_get() {
24451   int jresult ;
24452   int result;
24453
24454   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24455   jresult = (int)result;
24456   return jresult;
24457 }
24458
24459
24460 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_CLEAR_COLOR_get() {
24461   int jresult ;
24462   int result;
24463
24464   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24465   jresult = (int)result;
24466   return jresult;
24467 }
24468
24469
24470 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RenderTask_Property_REQUIRES_SYNC_get() {
24471   int jresult ;
24472   int result;
24473
24474   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24475   jresult = (int)result;
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask_Property() {
24481   void * jresult ;
24482   Dali::RenderTask::Property *result = 0 ;
24483
24484   {
24485     try {
24486       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24487     } catch (std::out_of_range& e) {
24488       {
24489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24490       };
24491     } catch (std::exception& e) {
24492       {
24493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24494       };
24495     } catch (...) {
24496       {
24497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24498       };
24499     }
24500   }
24501   jresult = (void *)result;
24502   return jresult;
24503 }
24504
24505
24506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTask_Property(void * jarg1) {
24507   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24508
24509   arg1 = (Dali::RenderTask::Property *)jarg1;
24510   {
24511     try {
24512       delete arg1;
24513     } catch (std::out_of_range& e) {
24514       {
24515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24516       };
24517     } catch (std::exception& e) {
24518       {
24519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24520       };
24521     } catch (...) {
24522       {
24523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24524       };
24525     }
24526   }
24527 }
24528
24529
24530 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24531   void * jresult ;
24532   bool (*result)(Dali::Vector2 &) = 0 ;
24533
24534   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24535   jresult = (void *)result;
24536   return jresult;
24537 }
24538
24539
24540 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24541   void * jresult ;
24542   bool (*result)(Dali::Vector2 &) = 0 ;
24543
24544   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24545   jresult = (void *)result;
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_EXCLUSIVE_get() {
24551   unsigned int jresult ;
24552   bool result;
24553
24554   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24555   jresult = result;
24556   return jresult;
24557 }
24558
24559
24560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24561   unsigned int jresult ;
24562   bool result;
24563
24564   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24565   jresult = result;
24566   return jresult;
24567 }
24568
24569
24570 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24571   void * jresult ;
24572   Dali::Vector4 *result = 0 ;
24573
24574   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24575   jresult = (void *)result;
24576   return jresult;
24577 }
24578
24579
24580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24581   unsigned int jresult ;
24582   bool result;
24583
24584   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24585   jresult = result;
24586   return jresult;
24587 }
24588
24589
24590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_CULL_MODE_get() {
24591   unsigned int jresult ;
24592   bool result;
24593
24594   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24595   jresult = result;
24596   return jresult;
24597 }
24598
24599
24600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_DEFAULT_REFRESH_RATE_get() {
24601   unsigned int jresult ;
24602   unsigned int result;
24603
24604   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24605   jresult = result;
24606   return jresult;
24607 }
24608
24609
24610 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask__SWIG_0() {
24611   void * jresult ;
24612   Dali::RenderTask *result = 0 ;
24613
24614   {
24615     try {
24616       result = (Dali::RenderTask *)new Dali::RenderTask();
24617     } catch (std::out_of_range& e) {
24618       {
24619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24620       };
24621     } catch (std::exception& e) {
24622       {
24623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24624       };
24625     } catch (...) {
24626       {
24627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24628       };
24629     }
24630   }
24631   jresult = (void *)result;
24632   return jresult;
24633 }
24634
24635
24636 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_DownCast(void * jarg1) {
24637   void * jresult ;
24638   Dali::BaseHandle arg1 ;
24639   Dali::BaseHandle *argp1 ;
24640   Dali::RenderTask result;
24641
24642   argp1 = (Dali::BaseHandle *)jarg1;
24643   if (!argp1) {
24644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24645     return 0;
24646   }
24647   arg1 = *argp1;
24648   {
24649     try {
24650       result = Dali::RenderTask::DownCast(arg1);
24651     } catch (std::out_of_range& e) {
24652       {
24653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24654       };
24655     } catch (std::exception& e) {
24656       {
24657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24658       };
24659     } catch (...) {
24660       {
24661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24662       };
24663     }
24664   }
24665   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24666   return jresult;
24667 }
24668
24669
24670 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTask(void * jarg1) {
24671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24672
24673   arg1 = (Dali::RenderTask *)jarg1;
24674   {
24675     try {
24676       delete arg1;
24677     } catch (std::out_of_range& e) {
24678       {
24679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24680       };
24681     } catch (std::exception& e) {
24682       {
24683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24684       };
24685     } catch (...) {
24686       {
24687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24688       };
24689     }
24690   }
24691 }
24692
24693
24694 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTask__SWIG_1(void * jarg1) {
24695   void * jresult ;
24696   Dali::RenderTask *arg1 = 0 ;
24697   Dali::RenderTask *result = 0 ;
24698
24699   arg1 = (Dali::RenderTask *)jarg1;
24700   if (!arg1) {
24701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24702     return 0;
24703   }
24704   {
24705     try {
24706       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24707     } catch (std::out_of_range& e) {
24708       {
24709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24710       };
24711     } catch (std::exception& e) {
24712       {
24713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (...) {
24716       {
24717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24718       };
24719     }
24720   }
24721   jresult = (void *)result;
24722   return jresult;
24723 }
24724
24725
24726 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_Assign(void * jarg1, void * jarg2) {
24727   void * jresult ;
24728   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24729   Dali::RenderTask *arg2 = 0 ;
24730   Dali::RenderTask *result = 0 ;
24731
24732   arg1 = (Dali::RenderTask *)jarg1;
24733   arg2 = (Dali::RenderTask *)jarg2;
24734   if (!arg2) {
24735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24736     return 0;
24737   }
24738   {
24739     try {
24740       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24741     } catch (std::out_of_range& e) {
24742       {
24743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24744       };
24745     } catch (std::exception& e) {
24746       {
24747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24748       };
24749     } catch (...) {
24750       {
24751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24752       };
24753     }
24754   }
24755   jresult = (void *)result;
24756   return jresult;
24757 }
24758
24759
24760 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24761   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24762   Dali::Actor arg2 ;
24763   Dali::Actor *argp2 ;
24764
24765   arg1 = (Dali::RenderTask *)jarg1;
24766   argp2 = (Dali::Actor *)jarg2;
24767   if (!argp2) {
24768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24769     return ;
24770   }
24771   arg2 = *argp2;
24772   {
24773     try {
24774       (arg1)->SetSourceActor(arg2);
24775     } catch (std::out_of_range& e) {
24776       {
24777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24778       };
24779     } catch (std::exception& e) {
24780       {
24781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24782       };
24783     } catch (...) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24786       };
24787     }
24788   }
24789 }
24790
24791
24792 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetSourceActor(void * jarg1) {
24793   void * jresult ;
24794   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24795   Dali::Actor result;
24796
24797   arg1 = (Dali::RenderTask *)jarg1;
24798   {
24799     try {
24800       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24801     } catch (std::out_of_range& e) {
24802       {
24803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24804       };
24805     } catch (std::exception& e) {
24806       {
24807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24808       };
24809     } catch (...) {
24810       {
24811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24812       };
24813     }
24814   }
24815   jresult = new Dali::Actor((const Dali::Actor &)result);
24816   return jresult;
24817 }
24818
24819
24820 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24821   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24822   bool arg2 ;
24823
24824   arg1 = (Dali::RenderTask *)jarg1;
24825   arg2 = jarg2 ? true : false;
24826   {
24827     try {
24828       (arg1)->SetExclusive(arg2);
24829     } catch (std::out_of_range& e) {
24830       {
24831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24832       };
24833     } catch (std::exception& e) {
24834       {
24835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24836       };
24837     } catch (...) {
24838       {
24839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24840       };
24841     }
24842   }
24843 }
24844
24845
24846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_IsExclusive(void * jarg1) {
24847   unsigned int jresult ;
24848   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24849   bool result;
24850
24851   arg1 = (Dali::RenderTask *)jarg1;
24852   {
24853     try {
24854       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24855     } catch (std::out_of_range& e) {
24856       {
24857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24858       };
24859     } catch (std::exception& e) {
24860       {
24861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24862       };
24863     } catch (...) {
24864       {
24865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24866       };
24867     }
24868   }
24869   jresult = result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24875   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24876   bool arg2 ;
24877
24878   arg1 = (Dali::RenderTask *)jarg1;
24879   arg2 = jarg2 ? true : false;
24880   {
24881     try {
24882       (arg1)->SetInputEnabled(arg2);
24883     } catch (std::out_of_range& e) {
24884       {
24885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24886       };
24887     } catch (std::exception& e) {
24888       {
24889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (...) {
24892       {
24893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24894       };
24895     }
24896   }
24897 }
24898
24899
24900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetInputEnabled(void * jarg1) {
24901   unsigned int jresult ;
24902   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24903   bool result;
24904
24905   arg1 = (Dali::RenderTask *)jarg1;
24906   {
24907     try {
24908       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
24909     } catch (std::out_of_range& e) {
24910       {
24911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24912       };
24913     } catch (std::exception& e) {
24914       {
24915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24916       };
24917     } catch (...) {
24918       {
24919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24920       };
24921     }
24922   }
24923   jresult = result;
24924   return jresult;
24925 }
24926
24927
24928 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
24929   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24930   Dali::CameraActor arg2 ;
24931   Dali::CameraActor *argp2 ;
24932
24933   arg1 = (Dali::RenderTask *)jarg1;
24934   argp2 = (Dali::CameraActor *)jarg2;
24935   if (!argp2) {
24936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
24937     return ;
24938   }
24939   arg2 = *argp2;
24940   {
24941     try {
24942       (arg1)->SetCameraActor(arg2);
24943     } catch (std::out_of_range& e) {
24944       {
24945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24946       };
24947     } catch (std::exception& e) {
24948       {
24949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24950       };
24951     } catch (...) {
24952       {
24953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24954       };
24955     }
24956   }
24957 }
24958
24959
24960 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCameraActor(void * jarg1) {
24961   void * jresult ;
24962   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24963   Dali::CameraActor result;
24964
24965   arg1 = (Dali::RenderTask *)jarg1;
24966   {
24967     try {
24968       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
24969     } catch (std::out_of_range& e) {
24970       {
24971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24972       };
24973     } catch (std::exception& e) {
24974       {
24975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24976       };
24977     } catch (...) {
24978       {
24979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24980       };
24981     }
24982   }
24983   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
24984   return jresult;
24985 }
24986
24987
24988 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
24989   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24990   Dali::FrameBufferImage arg2 ;
24991   Dali::FrameBufferImage *argp2 ;
24992
24993   arg1 = (Dali::RenderTask *)jarg1;
24994   argp2 = (Dali::FrameBufferImage *)jarg2;
24995   if (!argp2) {
24996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
24997     return ;
24998   }
24999   arg2 = *argp2;
25000   {
25001     try {
25002       (arg1)->SetTargetFrameBuffer(arg2);
25003     } catch (std::out_of_range& e) {
25004       {
25005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25006       };
25007     } catch (std::exception& e) {
25008       {
25009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25010       };
25011     } catch (...) {
25012       {
25013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25014       };
25015     }
25016   }
25017 }
25018
25019
25020 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25021   void * jresult ;
25022   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25023   Dali::FrameBufferImage result;
25024
25025   arg1 = (Dali::RenderTask *)jarg1;
25026   {
25027     try {
25028       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25029     } catch (std::out_of_range& e) {
25030       {
25031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25032       };
25033     } catch (std::exception& e) {
25034       {
25035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25036       };
25037     } catch (...) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25040       };
25041     }
25042   }
25043   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25044   return jresult;
25045 }
25046
25047
25048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25049   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25050   Dali::FrameBuffer arg2 ;
25051   Dali::FrameBuffer *argp2 ;
25052
25053   arg1 = (Dali::RenderTask *)jarg1;
25054   argp2 = (Dali::FrameBuffer *)jarg2;
25055   if (!argp2) {
25056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25057     return ;
25058   }
25059   arg2 = *argp2;
25060   {
25061     try {
25062       (arg1)->SetFrameBuffer(arg2);
25063     } catch (std::out_of_range& e) {
25064       {
25065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25066       };
25067     } catch (std::exception& e) {
25068       {
25069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25070       };
25071     } catch (...) {
25072       {
25073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25074       };
25075     }
25076   }
25077 }
25078
25079
25080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetFrameBuffer(void * jarg1) {
25081   void * jresult ;
25082   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25083   Dali::FrameBuffer result;
25084
25085   arg1 = (Dali::RenderTask *)jarg1;
25086   {
25087     try {
25088       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25089     } catch (std::out_of_range& e) {
25090       {
25091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (std::exception& e) {
25094       {
25095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25096       };
25097     } catch (...) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25100       };
25101     }
25102   }
25103   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25104   return jresult;
25105 }
25106
25107
25108 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25109   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25110   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25111
25112   arg1 = (Dali::RenderTask *)jarg1;
25113   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25114   {
25115     try {
25116       (arg1)->SetScreenToFrameBufferFunction(arg2);
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (...) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25128       };
25129     }
25130   }
25131 }
25132
25133
25134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25135   void * jresult ;
25136   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25137   Dali::RenderTask::ScreenToFrameBufferFunction result;
25138
25139   arg1 = (Dali::RenderTask *)jarg1;
25140   {
25141     try {
25142       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25143     } catch (std::out_of_range& e) {
25144       {
25145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25146       };
25147     } catch (std::exception& e) {
25148       {
25149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25150       };
25151     } catch (...) {
25152       {
25153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25154       };
25155     }
25156   }
25157   jresult = (void *)result;
25158   return jresult;
25159 }
25160
25161
25162 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25163   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25164   Dali::Actor arg2 ;
25165   Dali::Actor *argp2 ;
25166
25167   arg1 = (Dali::RenderTask *)jarg1;
25168   argp2 = (Dali::Actor *)jarg2;
25169   if (!argp2) {
25170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25171     return ;
25172   }
25173   arg2 = *argp2;
25174   {
25175     try {
25176       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25177     } catch (std::out_of_range& e) {
25178       {
25179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25180       };
25181     } catch (std::exception& e) {
25182       {
25183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25184       };
25185     } catch (...) {
25186       {
25187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25188       };
25189     }
25190   }
25191 }
25192
25193
25194 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25195   void * jresult ;
25196   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25197   Dali::Actor result;
25198
25199   arg1 = (Dali::RenderTask *)jarg1;
25200   {
25201     try {
25202       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25203     } catch (std::out_of_range& e) {
25204       {
25205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25206       };
25207     } catch (std::exception& e) {
25208       {
25209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25210       };
25211     } catch (...) {
25212       {
25213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25214       };
25215     }
25216   }
25217   jresult = new Dali::Actor((const Dali::Actor &)result);
25218   return jresult;
25219 }
25220
25221
25222 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25223   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25224   Dali::Vector2 arg2 ;
25225   Dali::Vector2 *argp2 ;
25226
25227   arg1 = (Dali::RenderTask *)jarg1;
25228   argp2 = (Dali::Vector2 *)jarg2;
25229   if (!argp2) {
25230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25231     return ;
25232   }
25233   arg2 = *argp2;
25234   {
25235     try {
25236       (arg1)->SetViewportPosition(arg2);
25237     } catch (std::out_of_range& e) {
25238       {
25239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25240       };
25241     } catch (std::exception& e) {
25242       {
25243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25244       };
25245     } catch (...) {
25246       {
25247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25248       };
25249     }
25250   }
25251 }
25252
25253
25254 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25255   void * jresult ;
25256   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25257   Dali::Vector2 result;
25258
25259   arg1 = (Dali::RenderTask *)jarg1;
25260   {
25261     try {
25262       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25263     } catch (std::out_of_range& e) {
25264       {
25265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25266       };
25267     } catch (std::exception& e) {
25268       {
25269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (...) {
25272       {
25273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25274       };
25275     }
25276   }
25277   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25278   return jresult;
25279 }
25280
25281
25282 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25283   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25284   Dali::Vector2 arg2 ;
25285   Dali::Vector2 *argp2 ;
25286
25287   arg1 = (Dali::RenderTask *)jarg1;
25288   argp2 = (Dali::Vector2 *)jarg2;
25289   if (!argp2) {
25290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25291     return ;
25292   }
25293   arg2 = *argp2;
25294   {
25295     try {
25296       (arg1)->SetViewportSize(arg2);
25297     } catch (std::out_of_range& e) {
25298       {
25299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25300       };
25301     } catch (std::exception& e) {
25302       {
25303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25304       };
25305     } catch (...) {
25306       {
25307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25308       };
25309     }
25310   }
25311 }
25312
25313
25314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetCurrentViewportSize(void * jarg1) {
25315   void * jresult ;
25316   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25317   Dali::Vector2 result;
25318
25319   arg1 = (Dali::RenderTask *)jarg1;
25320   {
25321     try {
25322       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25323     } catch (std::out_of_range& e) {
25324       {
25325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25326       };
25327     } catch (std::exception& e) {
25328       {
25329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25330       };
25331     } catch (...) {
25332       {
25333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25334       };
25335     }
25336   }
25337   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25338   return jresult;
25339 }
25340
25341
25342 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25343   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25344   Dali::Viewport arg2 ;
25345   Dali::Viewport *argp2 ;
25346
25347   arg1 = (Dali::RenderTask *)jarg1;
25348   argp2 = (Dali::Viewport *)jarg2;
25349   if (!argp2) {
25350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25351     return ;
25352   }
25353   arg2 = *argp2;
25354   {
25355     try {
25356       (arg1)->SetViewport(arg2);
25357     } catch (std::out_of_range& e) {
25358       {
25359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25360       };
25361     } catch (std::exception& e) {
25362       {
25363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25364       };
25365     } catch (...) {
25366       {
25367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25368       };
25369     }
25370   }
25371 }
25372
25373
25374 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetViewport(void * jarg1) {
25375   void * jresult ;
25376   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25377   Dali::Viewport result;
25378
25379   arg1 = (Dali::RenderTask *)jarg1;
25380   {
25381     try {
25382       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25383     } catch (std::out_of_range& e) {
25384       {
25385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25386       };
25387     } catch (std::exception& e) {
25388       {
25389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25390       };
25391     } catch (...) {
25392       {
25393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25394       };
25395     }
25396   }
25397   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25403   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25404   Dali::Vector4 *arg2 = 0 ;
25405
25406   arg1 = (Dali::RenderTask *)jarg1;
25407   arg2 = (Dali::Vector4 *)jarg2;
25408   if (!arg2) {
25409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25410     return ;
25411   }
25412   {
25413     try {
25414       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25426       };
25427     }
25428   }
25429 }
25430
25431
25432 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_GetClearColor(void * jarg1) {
25433   void * jresult ;
25434   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25435   Dali::Vector4 result;
25436
25437   arg1 = (Dali::RenderTask *)jarg1;
25438   {
25439     try {
25440       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25441     } catch (std::out_of_range& e) {
25442       {
25443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25444       };
25445     } catch (std::exception& e) {
25446       {
25447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25448       };
25449     } catch (...) {
25450       {
25451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25452       };
25453     }
25454   }
25455   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25456   return jresult;
25457 }
25458
25459
25460 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25462   bool arg2 ;
25463
25464   arg1 = (Dali::RenderTask *)jarg1;
25465   arg2 = jarg2 ? true : false;
25466   {
25467     try {
25468       (arg1)->SetClearEnabled(arg2);
25469     } catch (std::out_of_range& e) {
25470       {
25471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25472       };
25473     } catch (std::exception& e) {
25474       {
25475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25476       };
25477     } catch (...) {
25478       {
25479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25480       };
25481     }
25482   }
25483 }
25484
25485
25486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetClearEnabled(void * jarg1) {
25487   unsigned int jresult ;
25488   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25489   bool result;
25490
25491   arg1 = (Dali::RenderTask *)jarg1;
25492   {
25493     try {
25494       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25495     } catch (std::out_of_range& e) {
25496       {
25497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25498       };
25499     } catch (std::exception& e) {
25500       {
25501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (...) {
25504       {
25505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25506       };
25507     }
25508   }
25509   jresult = result;
25510   return jresult;
25511 }
25512
25513
25514 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25515   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25516   bool arg2 ;
25517
25518   arg1 = (Dali::RenderTask *)jarg1;
25519   arg2 = jarg2 ? true : false;
25520   {
25521     try {
25522       (arg1)->SetCullMode(arg2);
25523     } catch (std::out_of_range& e) {
25524       {
25525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25526       };
25527     } catch (std::exception& e) {
25528       {
25529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25530       };
25531     } catch (...) {
25532       {
25533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25534       };
25535     }
25536   }
25537 }
25538
25539
25540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetCullMode(void * jarg1) {
25541   unsigned int jresult ;
25542   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25543   bool result;
25544
25545   arg1 = (Dali::RenderTask *)jarg1;
25546   {
25547     try {
25548       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25560       };
25561     }
25562   }
25563   jresult = result;
25564   return jresult;
25565 }
25566
25567
25568 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25569   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25570   unsigned int arg2 ;
25571
25572   arg1 = (Dali::RenderTask *)jarg1;
25573   arg2 = (unsigned int)jarg2;
25574   {
25575     try {
25576       (arg1)->SetRefreshRate(arg2);
25577     } catch (std::out_of_range& e) {
25578       {
25579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25580       };
25581     } catch (std::exception& e) {
25582       {
25583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25584       };
25585     } catch (...) {
25586       {
25587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25588       };
25589     }
25590   }
25591 }
25592
25593
25594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_GetRefreshRate(void * jarg1) {
25595   unsigned int jresult ;
25596   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25597   unsigned int result;
25598
25599   arg1 = (Dali::RenderTask *)jarg1;
25600   {
25601     try {
25602       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25603     } catch (std::out_of_range& e) {
25604       {
25605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25606       };
25607     } catch (std::exception& e) {
25608       {
25609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25610       };
25611     } catch (...) {
25612       {
25613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25614       };
25615     }
25616   }
25617   jresult = result;
25618   return jresult;
25619 }
25620
25621
25622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25623   unsigned int jresult ;
25624   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25625   Dali::Vector3 *arg2 = 0 ;
25626   float *arg3 = 0 ;
25627   float *arg4 = 0 ;
25628   bool result;
25629
25630   arg1 = (Dali::RenderTask *)jarg1;
25631   arg2 = (Dali::Vector3 *)jarg2;
25632   if (!arg2) {
25633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25634     return 0;
25635   }
25636   arg3 = (float *)jarg3;
25637   arg4 = (float *)jarg4;
25638   {
25639     try {
25640       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25641     } catch (std::out_of_range& e) {
25642       {
25643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25644       };
25645     } catch (std::exception& e) {
25646       {
25647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25648       };
25649     } catch (...) {
25650       {
25651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25652       };
25653     }
25654   }
25655   jresult = result;
25656   return jresult;
25657 }
25658
25659
25660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25661   unsigned int jresult ;
25662   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25663   Dali::Actor arg2 ;
25664   float arg3 ;
25665   float arg4 ;
25666   float *arg5 = 0 ;
25667   float *arg6 = 0 ;
25668   Dali::Actor *argp2 ;
25669   bool result;
25670
25671   arg1 = (Dali::RenderTask *)jarg1;
25672   argp2 = (Dali::Actor *)jarg2;
25673   if (!argp2) {
25674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25675     return 0;
25676   }
25677   arg2 = *argp2;
25678   arg3 = (float)jarg3;
25679   arg4 = (float)jarg4;
25680   arg5 = (float *)jarg5;
25681   arg6 = (float *)jarg6;
25682   {
25683     try {
25684       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25685     } catch (std::out_of_range& e) {
25686       {
25687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25688       };
25689     } catch (std::exception& e) {
25690       {
25691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (...) {
25694       {
25695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25696       };
25697     }
25698   }
25699   jresult = result;
25700   return jresult;
25701 }
25702
25703
25704 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RenderTask_FinishedSignal(void * jarg1) {
25705   void * jresult ;
25706   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25707   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25708
25709   arg1 = (Dali::RenderTask *)jarg1;
25710   {
25711     try {
25712       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25713     } catch (std::out_of_range& e) {
25714       {
25715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25716       };
25717     } catch (std::exception& e) {
25718       {
25719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (...) {
25722       {
25723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25724       };
25725     }
25726   }
25727   jresult = (void *)result;
25728   return jresult;
25729 }
25730
25731
25732 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25733   void * jresult ;
25734   int arg1 ;
25735   Dali::TouchPoint::State arg2 ;
25736   float arg3 ;
25737   float arg4 ;
25738   Dali::TouchPoint *result = 0 ;
25739
25740   arg1 = (int)jarg1;
25741   arg2 = (Dali::TouchPoint::State)jarg2;
25742   arg3 = (float)jarg3;
25743   arg4 = (float)jarg4;
25744   {
25745     try {
25746       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25747     } catch (std::out_of_range& e) {
25748       {
25749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25750       };
25751     } catch (std::exception& e) {
25752       {
25753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (...) {
25756       {
25757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25758       };
25759     }
25760   }
25761   jresult = (void *)result;
25762   return jresult;
25763 }
25764
25765
25766 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25767   void * jresult ;
25768   int arg1 ;
25769   Dali::TouchPoint::State arg2 ;
25770   float arg3 ;
25771   float arg4 ;
25772   float arg5 ;
25773   float arg6 ;
25774   Dali::TouchPoint *result = 0 ;
25775
25776   arg1 = (int)jarg1;
25777   arg2 = (Dali::TouchPoint::State)jarg2;
25778   arg3 = (float)jarg3;
25779   arg4 = (float)jarg4;
25780   arg5 = (float)jarg5;
25781   arg6 = (float)jarg6;
25782   {
25783     try {
25784       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25785     } catch (std::out_of_range& e) {
25786       {
25787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25788       };
25789     } catch (std::exception& e) {
25790       {
25791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25796       };
25797     }
25798   }
25799   jresult = (void *)result;
25800   return jresult;
25801 }
25802
25803
25804 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchPoint(void * jarg1) {
25805   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25806
25807   arg1 = (Dali::TouchPoint *)jarg1;
25808   {
25809     try {
25810       delete arg1;
25811     } catch (std::out_of_range& e) {
25812       {
25813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25814       };
25815     } catch (std::exception& e) {
25816       {
25817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25818       };
25819     } catch (...) {
25820       {
25821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25822       };
25823     }
25824   }
25825 }
25826
25827
25828 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25829   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25830   int arg2 ;
25831
25832   arg1 = (Dali::TouchPoint *)jarg1;
25833   arg2 = (int)jarg2;
25834   if (arg1) (arg1)->deviceId = arg2;
25835 }
25836
25837
25838 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchPoint_deviceId_get(void * jarg1) {
25839   int jresult ;
25840   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25841   int result;
25842
25843   arg1 = (Dali::TouchPoint *)jarg1;
25844   result = (int) ((arg1)->deviceId);
25845   jresult = result;
25846   return jresult;
25847 }
25848
25849
25850 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_state_set(void * jarg1, int jarg2) {
25851   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25852   Dali::TouchPoint::State arg2 ;
25853
25854   arg1 = (Dali::TouchPoint *)jarg1;
25855   arg2 = (Dali::TouchPoint::State)jarg2;
25856   if (arg1) (arg1)->state = arg2;
25857 }
25858
25859
25860 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchPoint_state_get(void * jarg1) {
25861   int jresult ;
25862   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25863   Dali::TouchPoint::State result;
25864
25865   arg1 = (Dali::TouchPoint *)jarg1;
25866   result = (Dali::TouchPoint::State) ((arg1)->state);
25867   jresult = (int)result;
25868   return jresult;
25869 }
25870
25871
25872 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25873   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25874   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25875
25876   arg1 = (Dali::TouchPoint *)jarg1;
25877   arg2 = (Dali::Actor *)jarg2;
25878   if (arg1) (arg1)->hitActor = *arg2;
25879 }
25880
25881
25882 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_hitActor_get(void * jarg1) {
25883   void * jresult ;
25884   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25885   Dali::Actor *result = 0 ;
25886
25887   arg1 = (Dali::TouchPoint *)jarg1;
25888   result = (Dali::Actor *)& ((arg1)->hitActor);
25889   jresult = (void *)result;
25890   return jresult;
25891 }
25892
25893
25894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_local_set(void * jarg1, void * jarg2) {
25895   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25896   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25897
25898   arg1 = (Dali::TouchPoint *)jarg1;
25899   arg2 = (Dali::Vector2 *)jarg2;
25900   if (arg1) (arg1)->local = *arg2;
25901 }
25902
25903
25904 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_local_get(void * jarg1) {
25905   void * jresult ;
25906   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25907   Dali::Vector2 *result = 0 ;
25908
25909   arg1 = (Dali::TouchPoint *)jarg1;
25910   result = (Dali::Vector2 *)& ((arg1)->local);
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPoint_screen_set(void * jarg1, void * jarg2) {
25917   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25918   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25919
25920   arg1 = (Dali::TouchPoint *)jarg1;
25921   arg2 = (Dali::Vector2 *)jarg2;
25922   if (arg1) (arg1)->screen = *arg2;
25923 }
25924
25925
25926 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPoint_screen_get(void * jarg1) {
25927   void * jresult ;
25928   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25929   Dali::Vector2 *result = 0 ;
25930
25931   arg1 = (Dali::TouchPoint *)jarg1;
25932   result = (Dali::Vector2 *)& ((arg1)->screen);
25933   jresult = (void *)result;
25934   return jresult;
25935 }
25936
25937
25938 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchData__SWIG_0() {
25939   void * jresult ;
25940   Dali::TouchData *result = 0 ;
25941
25942   {
25943     try {
25944       result = (Dali::TouchData *)new Dali::TouchData();
25945     } catch (std::out_of_range& e) {
25946       {
25947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25948       };
25949     } catch (std::exception& e) {
25950       {
25951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25952       };
25953     } catch (...) {
25954       {
25955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25956       };
25957     }
25958   }
25959   jresult = (void *)result;
25960   return jresult;
25961 }
25962
25963
25964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchData__SWIG_1(void * jarg1) {
25965   void * jresult ;
25966   Dali::TouchData *arg1 = 0 ;
25967   Dali::TouchData *result = 0 ;
25968
25969   arg1 = (Dali::TouchData *)jarg1;
25970   if (!arg1) {
25971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
25972     return 0;
25973   }
25974   {
25975     try {
25976       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
25977     } catch (std::out_of_range& e) {
25978       {
25979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25980       };
25981     } catch (std::exception& e) {
25982       {
25983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25984       };
25985     } catch (...) {
25986       {
25987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25988       };
25989     }
25990   }
25991   jresult = (void *)result;
25992   return jresult;
25993 }
25994
25995
25996 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchData(void * jarg1) {
25997   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
25998
25999   arg1 = (Dali::TouchData *)jarg1;
26000   {
26001     try {
26002       delete arg1;
26003     } catch (std::out_of_range& e) {
26004       {
26005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (std::exception& e) {
26008       {
26009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26010       };
26011     } catch (...) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26014       };
26015     }
26016   }
26017 }
26018
26019
26020 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_Assign(void * jarg1, void * jarg2) {
26021   void * jresult ;
26022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26023   Dali::TouchData *arg2 = 0 ;
26024   Dali::TouchData *result = 0 ;
26025
26026   arg1 = (Dali::TouchData *)jarg1;
26027   arg2 = (Dali::TouchData *)jarg2;
26028   if (!arg2) {
26029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26030     return 0;
26031   }
26032   {
26033     try {
26034       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26035     } catch (std::out_of_range& e) {
26036       {
26037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26038       };
26039     } catch (std::exception& e) {
26040       {
26041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26042       };
26043     } catch (...) {
26044       {
26045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26046       };
26047     }
26048   }
26049   jresult = (void *)result;
26050   return jresult;
26051 }
26052
26053
26054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchData_GetTime(void * jarg1) {
26055   unsigned long jresult ;
26056   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26057   unsigned long result;
26058
26059   arg1 = (Dali::TouchData *)jarg1;
26060   {
26061     try {
26062       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26063     } catch (std::out_of_range& e) {
26064       {
26065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26066       };
26067     } catch (std::exception& e) {
26068       {
26069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26070       };
26071     } catch (...) {
26072       {
26073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26074       };
26075     }
26076   }
26077   jresult = (unsigned long)result;
26078   return jresult;
26079 }
26080
26081
26082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchData_GetPointCount(void * jarg1) {
26083   unsigned long jresult ;
26084   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26085   std::size_t result;
26086
26087   arg1 = (Dali::TouchData *)jarg1;
26088   {
26089     try {
26090       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26091     } catch (std::out_of_range& e) {
26092       {
26093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26094       };
26095     } catch (std::exception& e) {
26096       {
26097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26098       };
26099     } catch (...) {
26100       {
26101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26102       };
26103     }
26104   }
26105   jresult = (unsigned long)result;
26106   return jresult;
26107 }
26108
26109
26110 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchData_GetDeviceId(void * jarg1, unsigned long jarg2) {
26111   int jresult ;
26112   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26113   std::size_t arg2 ;
26114   int32_t result;
26115
26116   arg1 = (Dali::TouchData *)jarg1;
26117   arg2 = (std::size_t)jarg2;
26118   {
26119     try {
26120       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26121     } catch (std::out_of_range& e) {
26122       {
26123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26124       };
26125     } catch (std::exception& e) {
26126       {
26127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26128       };
26129     } catch (...) {
26130       {
26131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26132       };
26133     }
26134   }
26135   jresult = result;
26136   return jresult;
26137 }
26138
26139
26140 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TouchData_GetState(void * jarg1, unsigned long jarg2) {
26141   int jresult ;
26142   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26143   std::size_t arg2 ;
26144   Dali::PointState::Type result;
26145
26146   arg1 = (Dali::TouchData *)jarg1;
26147   arg2 = (std::size_t)jarg2;
26148   {
26149     try {
26150       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26151     } catch (std::out_of_range& e) {
26152       {
26153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26154       };
26155     } catch (std::exception& e) {
26156       {
26157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26158       };
26159     } catch (...) {
26160       {
26161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26162       };
26163     }
26164   }
26165   jresult = (int)result;
26166   return jresult;
26167 }
26168
26169
26170 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetHitActor(void * jarg1, unsigned long jarg2) {
26171   void * jresult ;
26172   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26173   std::size_t arg2 ;
26174   Dali::Actor result;
26175
26176   arg1 = (Dali::TouchData *)jarg1;
26177   arg2 = (std::size_t)jarg2;
26178   {
26179     try {
26180       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26181     } catch (std::out_of_range& e) {
26182       {
26183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26184       };
26185     } catch (std::exception& e) {
26186       {
26187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26188       };
26189     } catch (...) {
26190       {
26191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26192       };
26193     }
26194   }
26195   jresult = new Dali::Actor((const Dali::Actor &)result);
26196   return jresult;
26197 }
26198
26199
26200 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26201   void * jresult ;
26202   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26203   std::size_t arg2 ;
26204   Dali::Vector2 *result = 0 ;
26205
26206   arg1 = (Dali::TouchData *)jarg1;
26207   arg2 = (std::size_t)jarg2;
26208   {
26209     try {
26210       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26211     } catch (std::out_of_range& e) {
26212       {
26213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26214       };
26215     } catch (std::exception& e) {
26216       {
26217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26218       };
26219     } catch (...) {
26220       {
26221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26222       };
26223     }
26224   }
26225   jresult = (void *)result;
26226   return jresult;
26227 }
26228
26229
26230 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26231   void * jresult ;
26232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26233   std::size_t arg2 ;
26234   Dali::Vector2 *result = 0 ;
26235
26236   arg1 = (Dali::TouchData *)jarg1;
26237   arg2 = (std::size_t)jarg2;
26238   {
26239     try {
26240       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26241     } catch (std::out_of_range& e) {
26242       {
26243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26244       };
26245     } catch (std::exception& e) {
26246       {
26247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26248       };
26249     } catch (...) {
26250       {
26251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26252       };
26253     }
26254   }
26255   jresult = (void *)result;
26256   return jresult;
26257 }
26258
26259
26260 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TouchData_GetRadius(void * jarg1, unsigned long jarg2) {
26261   float jresult ;
26262   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26263   std::size_t arg2 ;
26264   float result;
26265
26266   arg1 = (Dali::TouchData *)jarg1;
26267   arg2 = (std::size_t)jarg2;
26268   {
26269     try {
26270       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26271     } catch (std::out_of_range& e) {
26272       {
26273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26274       };
26275     } catch (std::exception& e) {
26276       {
26277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (...) {
26280       {
26281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26282       };
26283     }
26284   }
26285   jresult = result;
26286   return jresult;
26287 }
26288
26289
26290 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26291   void * jresult ;
26292   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26293   std::size_t arg2 ;
26294   Dali::Vector2 *result = 0 ;
26295
26296   arg1 = (Dali::TouchData *)jarg1;
26297   arg2 = (std::size_t)jarg2;
26298   {
26299     try {
26300       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26301     } catch (std::out_of_range& e) {
26302       {
26303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26304       };
26305     } catch (std::exception& e) {
26306       {
26307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26308       };
26309     } catch (...) {
26310       {
26311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26312       };
26313     }
26314   }
26315   jresult = (void *)result;
26316   return jresult;
26317 }
26318
26319
26320 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TouchData_GetPressure(void * jarg1, unsigned long jarg2) {
26321   float jresult ;
26322   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26323   std::size_t arg2 ;
26324   float result;
26325
26326   arg1 = (Dali::TouchData *)jarg1;
26327   arg2 = (std::size_t)jarg2;
26328   {
26329     try {
26330       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26331     } catch (std::out_of_range& e) {
26332       {
26333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26334       };
26335     } catch (std::exception& e) {
26336       {
26337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26338       };
26339     } catch (...) {
26340       {
26341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26342       };
26343     }
26344   }
26345   jresult = result;
26346   return jresult;
26347 }
26348
26349
26350 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchData_GetAngle(void * jarg1, unsigned long jarg2) {
26351   void * jresult ;
26352   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26353   std::size_t arg2 ;
26354   Dali::Degree result;
26355
26356   arg1 = (Dali::TouchData *)jarg1;
26357   arg2 = (std::size_t)jarg2;
26358   {
26359     try {
26360       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26361     } catch (std::out_of_range& e) {
26362       {
26363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26364       };
26365     } catch (std::exception& e) {
26366       {
26367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26368       };
26369     } catch (...) {
26370       {
26371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26372       };
26373     }
26374   }
26375   jresult = new Dali::Degree((const Dali::Degree &)result);
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GestureDetector__SWIG_0() {
26381   void * jresult ;
26382   Dali::GestureDetector *result = 0 ;
26383
26384   {
26385     try {
26386       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26387     } catch (std::out_of_range& e) {
26388       {
26389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26390       };
26391     } catch (std::exception& e) {
26392       {
26393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26394       };
26395     } catch (...) {
26396       {
26397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26398       };
26399     }
26400   }
26401   jresult = (void *)result;
26402   return jresult;
26403 }
26404
26405
26406 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_DownCast(void * jarg1) {
26407   void * jresult ;
26408   Dali::BaseHandle arg1 ;
26409   Dali::BaseHandle *argp1 ;
26410   Dali::GestureDetector result;
26411
26412   argp1 = (Dali::BaseHandle *)jarg1;
26413   if (!argp1) {
26414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26415     return 0;
26416   }
26417   arg1 = *argp1;
26418   {
26419     try {
26420       result = Dali::GestureDetector::DownCast(arg1);
26421     } catch (std::out_of_range& e) {
26422       {
26423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26424       };
26425     } catch (std::exception& e) {
26426       {
26427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26428       };
26429     } catch (...) {
26430       {
26431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26432       };
26433     }
26434   }
26435   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26436   return jresult;
26437 }
26438
26439
26440 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GestureDetector(void * jarg1) {
26441   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26442
26443   arg1 = (Dali::GestureDetector *)jarg1;
26444   {
26445     try {
26446       delete arg1;
26447     } catch (std::out_of_range& e) {
26448       {
26449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26450       };
26451     } catch (std::exception& e) {
26452       {
26453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26454       };
26455     } catch (...) {
26456       {
26457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26458       };
26459     }
26460   }
26461 }
26462
26463
26464 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GestureDetector__SWIG_1(void * jarg1) {
26465   void * jresult ;
26466   Dali::GestureDetector *arg1 = 0 ;
26467   Dali::GestureDetector *result = 0 ;
26468
26469   arg1 = (Dali::GestureDetector *)jarg1;
26470   if (!arg1) {
26471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26472     return 0;
26473   }
26474   {
26475     try {
26476       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26477     } catch (std::out_of_range& e) {
26478       {
26479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26480       };
26481     } catch (std::exception& e) {
26482       {
26483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26484       };
26485     } catch (...) {
26486       {
26487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26488       };
26489     }
26490   }
26491   jresult = (void *)result;
26492   return jresult;
26493 }
26494
26495
26496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_Assign(void * jarg1, void * jarg2) {
26497   void * jresult ;
26498   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26499   Dali::GestureDetector *arg2 = 0 ;
26500   Dali::GestureDetector *result = 0 ;
26501
26502   arg1 = (Dali::GestureDetector *)jarg1;
26503   arg2 = (Dali::GestureDetector *)jarg2;
26504   if (!arg2) {
26505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26506     return 0;
26507   }
26508   {
26509     try {
26510       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26511     } catch (std::out_of_range& e) {
26512       {
26513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26514       };
26515     } catch (std::exception& e) {
26516       {
26517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26518       };
26519     } catch (...) {
26520       {
26521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26522       };
26523     }
26524   }
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_Attach(void * jarg1, void * jarg2) {
26531   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26532   Dali::Actor arg2 ;
26533   Dali::Actor *argp2 ;
26534
26535   arg1 = (Dali::GestureDetector *)jarg1;
26536   argp2 = (Dali::Actor *)jarg2;
26537   if (!argp2) {
26538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26539     return ;
26540   }
26541   arg2 = *argp2;
26542   {
26543     try {
26544       (arg1)->Attach(arg2);
26545     } catch (std::out_of_range& e) {
26546       {
26547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26548       };
26549     } catch (std::exception& e) {
26550       {
26551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26552       };
26553     } catch (...) {
26554       {
26555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26556       };
26557     }
26558   }
26559 }
26560
26561
26562 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_Detach(void * jarg1, void * jarg2) {
26563   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26564   Dali::Actor arg2 ;
26565   Dali::Actor *argp2 ;
26566
26567   arg1 = (Dali::GestureDetector *)jarg1;
26568   argp2 = (Dali::Actor *)jarg2;
26569   if (!argp2) {
26570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26571     return ;
26572   }
26573   arg2 = *argp2;
26574   {
26575     try {
26576       (arg1)->Detach(arg2);
26577     } catch (std::out_of_range& e) {
26578       {
26579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26580       };
26581     } catch (std::exception& e) {
26582       {
26583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26584       };
26585     } catch (...) {
26586       {
26587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26588       };
26589     }
26590   }
26591 }
26592
26593
26594 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GestureDetector_DetachAll(void * jarg1) {
26595   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26596
26597   arg1 = (Dali::GestureDetector *)jarg1;
26598   {
26599     try {
26600       (arg1)->DetachAll();
26601     } catch (std::out_of_range& e) {
26602       {
26603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26604       };
26605     } catch (std::exception& e) {
26606       {
26607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26608       };
26609     } catch (...) {
26610       {
26611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26612       };
26613     }
26614   }
26615 }
26616
26617
26618 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_GestureDetector_GetAttachedActorCount(void * jarg1) {
26619   unsigned long jresult ;
26620   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26621   size_t result;
26622
26623   arg1 = (Dali::GestureDetector *)jarg1;
26624   {
26625     try {
26626       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26627     } catch (std::out_of_range& e) {
26628       {
26629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26630       };
26631     } catch (std::exception& e) {
26632       {
26633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26634       };
26635     } catch (...) {
26636       {
26637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26638       };
26639     }
26640   }
26641   jresult = (unsigned long)result;
26642   return jresult;
26643 }
26644
26645
26646 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26647   void * jresult ;
26648   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26649   size_t arg2 ;
26650   Dali::Actor result;
26651
26652   arg1 = (Dali::GestureDetector *)jarg1;
26653   arg2 = (size_t)jarg2;
26654   {
26655     try {
26656       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26657     } catch (std::out_of_range& e) {
26658       {
26659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26660       };
26661     } catch (std::exception& e) {
26662       {
26663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26664       };
26665     } catch (...) {
26666       {
26667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26668       };
26669     }
26670   }
26671   jresult = new Dali::Actor((const Dali::Actor &)result);
26672   return jresult;
26673 }
26674
26675
26676 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Gesture(void * jarg1) {
26677   void * jresult ;
26678   Dali::Gesture *arg1 = 0 ;
26679   Dali::Gesture *result = 0 ;
26680
26681   arg1 = (Dali::Gesture *)jarg1;
26682   if (!arg1) {
26683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26684     return 0;
26685   }
26686   {
26687     try {
26688       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26700       };
26701     }
26702   }
26703   jresult = (void *)result;
26704   return jresult;
26705 }
26706
26707
26708 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Gesture_Assign(void * jarg1, void * jarg2) {
26709   void * jresult ;
26710   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26711   Dali::Gesture *arg2 = 0 ;
26712   Dali::Gesture *result = 0 ;
26713
26714   arg1 = (Dali::Gesture *)jarg1;
26715   arg2 = (Dali::Gesture *)jarg2;
26716   if (!arg2) {
26717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26718     return 0;
26719   }
26720   {
26721     try {
26722       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26723     } catch (std::out_of_range& e) {
26724       {
26725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26726       };
26727     } catch (std::exception& e) {
26728       {
26729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26730       };
26731     } catch (...) {
26732       {
26733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26734       };
26735     }
26736   }
26737   jresult = (void *)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Gesture(void * jarg1) {
26743   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26744
26745   arg1 = (Dali::Gesture *)jarg1;
26746   {
26747     try {
26748       delete arg1;
26749     } catch (std::out_of_range& e) {
26750       {
26751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26752       };
26753     } catch (std::exception& e) {
26754       {
26755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26756       };
26757     } catch (...) {
26758       {
26759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26760       };
26761     }
26762   }
26763 }
26764
26765
26766 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_type_set(void * jarg1, int jarg2) {
26767   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26768   Dali::Gesture::Type arg2 ;
26769
26770   arg1 = (Dali::Gesture *)jarg1;
26771   arg2 = (Dali::Gesture::Type)jarg2;
26772   if (arg1) (arg1)->type = arg2;
26773 }
26774
26775
26776 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Gesture_type_get(void * jarg1) {
26777   int jresult ;
26778   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26779   Dali::Gesture::Type result;
26780
26781   arg1 = (Dali::Gesture *)jarg1;
26782   result = (Dali::Gesture::Type) ((arg1)->type);
26783   jresult = (int)result;
26784   return jresult;
26785 }
26786
26787
26788 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_state_set(void * jarg1, int jarg2) {
26789   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26790   Dali::Gesture::State arg2 ;
26791
26792   arg1 = (Dali::Gesture *)jarg1;
26793   arg2 = (Dali::Gesture::State)jarg2;
26794   if (arg1) (arg1)->state = arg2;
26795 }
26796
26797
26798 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Gesture_state_get(void * jarg1) {
26799   int jresult ;
26800   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26801   Dali::Gesture::State result;
26802
26803   arg1 = (Dali::Gesture *)jarg1;
26804   result = (Dali::Gesture::State) ((arg1)->state);
26805   jresult = (int)result;
26806   return jresult;
26807 }
26808
26809
26810 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26811   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26812   unsigned int arg2 ;
26813
26814   arg1 = (Dali::Gesture *)jarg1;
26815   arg2 = (unsigned int)jarg2;
26816   if (arg1) (arg1)->time = arg2;
26817 }
26818
26819
26820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Gesture_time_get(void * jarg1) {
26821   unsigned int jresult ;
26822   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26823   unsigned int result;
26824
26825   arg1 = (Dali::Gesture *)jarg1;
26826   result = (unsigned int) ((arg1)->time);
26827   jresult = result;
26828   return jresult;
26829 }
26830
26831
26832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_HoverEvent__SWIG_0() {
26833   void * jresult ;
26834   Dali::HoverEvent *result = 0 ;
26835
26836   {
26837     try {
26838       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26846       };
26847     } catch (...) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26850       };
26851     }
26852   }
26853   jresult = (void *)result;
26854   return jresult;
26855 }
26856
26857
26858 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_HoverEvent__SWIG_1(unsigned long jarg1) {
26859   void * jresult ;
26860   unsigned long arg1 ;
26861   Dali::HoverEvent *result = 0 ;
26862
26863   arg1 = (unsigned long)jarg1;
26864   {
26865     try {
26866       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26867     } catch (std::out_of_range& e) {
26868       {
26869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26870       };
26871     } catch (std::exception& e) {
26872       {
26873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26874       };
26875     } catch (...) {
26876       {
26877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26878       };
26879     }
26880   }
26881   jresult = (void *)result;
26882   return jresult;
26883 }
26884
26885
26886 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_HoverEvent(void * jarg1) {
26887   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26888
26889   arg1 = (Dali::HoverEvent *)jarg1;
26890   {
26891     try {
26892       delete arg1;
26893     } catch (std::out_of_range& e) {
26894       {
26895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26896       };
26897     } catch (std::exception& e) {
26898       {
26899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26900       };
26901     } catch (...) {
26902       {
26903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26904       };
26905     }
26906   }
26907 }
26908
26909
26910 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_HoverEvent_points_set(void * jarg1, void * jarg2) {
26911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26912   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
26913
26914   arg1 = (Dali::HoverEvent *)jarg1;
26915   arg2 = (Dali::TouchPointContainer *)jarg2;
26916   if (arg1) (arg1)->points = *arg2;
26917 }
26918
26919
26920 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_HoverEvent_points_get(void * jarg1) {
26921   void * jresult ;
26922   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26923   Dali::TouchPointContainer *result = 0 ;
26924
26925   arg1 = (Dali::HoverEvent *)jarg1;
26926   result = (Dali::TouchPointContainer *)& ((arg1)->points);
26927   jresult = (void *)result;
26928   return jresult;
26929 }
26930
26931
26932 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_HoverEvent_time_set(void * jarg1, unsigned long jarg2) {
26933   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26934   unsigned long arg2 ;
26935
26936   arg1 = (Dali::HoverEvent *)jarg1;
26937   arg2 = (unsigned long)jarg2;
26938   if (arg1) (arg1)->time = arg2;
26939 }
26940
26941
26942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_HoverEvent_time_get(void * jarg1) {
26943   unsigned long jresult ;
26944   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26945   unsigned long result;
26946
26947   arg1 = (Dali::HoverEvent *)jarg1;
26948   result = (unsigned long) ((arg1)->time);
26949   jresult = (unsigned long)result;
26950   return jresult;
26951 }
26952
26953
26954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_HoverEvent_GetPointCount(void * jarg1) {
26955   unsigned int jresult ;
26956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26957   unsigned int result;
26958
26959   arg1 = (Dali::HoverEvent *)jarg1;
26960   {
26961     try {
26962       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
26963     } catch (std::out_of_range& e) {
26964       {
26965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26966       };
26967     } catch (std::exception& e) {
26968       {
26969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26970       };
26971     } catch (...) {
26972       {
26973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26974       };
26975     }
26976   }
26977   jresult = result;
26978   return jresult;
26979 }
26980
26981
26982 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_HoverEvent_GetPoint(void * jarg1, unsigned int jarg2) {
26983   void * jresult ;
26984   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26985   unsigned int arg2 ;
26986   Dali::TouchPoint *result = 0 ;
26987
26988   arg1 = (Dali::HoverEvent *)jarg1;
26989   arg2 = (unsigned int)jarg2;
26990   {
26991     try {
26992       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
26993     } catch (std::out_of_range& e) {
26994       {
26995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26996       };
26997     } catch (std::exception& e) {
26998       {
26999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27000       };
27001     } catch (...) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27004       };
27005     }
27006   }
27007   jresult = (void *)result;
27008   return jresult;
27009 }
27010
27011
27012 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEvent__SWIG_0() {
27013   void * jresult ;
27014   Dali::KeyEvent *result = 0 ;
27015
27016   {
27017     try {
27018       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27019     } catch (std::out_of_range& e) {
27020       {
27021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27022       };
27023     } catch (std::exception& e) {
27024       {
27025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27026       };
27027     } catch (...) {
27028       {
27029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27030       };
27031     }
27032   }
27033   jresult = (void *)result;
27034   return jresult;
27035 }
27036
27037
27038 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEvent__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27039   void * jresult ;
27040   std::string *arg1 = 0 ;
27041   std::string *arg2 = 0 ;
27042   int arg3 ;
27043   int arg4 ;
27044   unsigned long arg5 ;
27045   Dali::KeyEvent::State *arg6 = 0 ;
27046   Dali::KeyEvent::State temp6 ;
27047   Dali::KeyEvent *result = 0 ;
27048
27049   if (!jarg1) {
27050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27051     return 0;
27052   }
27053   std::string arg1_str(jarg1);
27054   arg1 = &arg1_str;
27055   if (!jarg2) {
27056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27057     return 0;
27058   }
27059   std::string arg2_str(jarg2);
27060   arg2 = &arg2_str;
27061   arg3 = (int)jarg3;
27062   arg4 = (int)jarg4;
27063   arg5 = (unsigned long)jarg5;
27064   temp6 = (Dali::KeyEvent::State)jarg6;
27065   arg6 = &temp6;
27066   {
27067     try {
27068       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27069     } catch (std::out_of_range& e) {
27070       {
27071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27072       };
27073     } catch (std::exception& e) {
27074       {
27075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27076       };
27077     } catch (...) {
27078       {
27079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27080       };
27081     }
27082   }
27083   jresult = (void *)result;
27084
27085   //argout typemap for const std::string&
27086
27087
27088   //argout typemap for const std::string&
27089
27090   return jresult;
27091 }
27092
27093
27094 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyEvent(void * jarg1) {
27095   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27096
27097   arg1 = (Dali::KeyEvent *)jarg1;
27098   {
27099     try {
27100       delete arg1;
27101     } catch (std::out_of_range& e) {
27102       {
27103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27104       };
27105     } catch (std::exception& e) {
27106       {
27107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27108       };
27109     } catch (...) {
27110       {
27111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27112       };
27113     }
27114   }
27115 }
27116
27117
27118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsShiftModifier(void * jarg1) {
27119   unsigned int jresult ;
27120   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27121   bool result;
27122
27123   arg1 = (Dali::KeyEvent *)jarg1;
27124   {
27125     try {
27126       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27127     } catch (std::out_of_range& e) {
27128       {
27129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27130       };
27131     } catch (std::exception& e) {
27132       {
27133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27138       };
27139     }
27140   }
27141   jresult = result;
27142   return jresult;
27143 }
27144
27145
27146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsCtrlModifier(void * jarg1) {
27147   unsigned int jresult ;
27148   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27149   bool result;
27150
27151   arg1 = (Dali::KeyEvent *)jarg1;
27152   {
27153     try {
27154       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27162       };
27163     } catch (...) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27166       };
27167     }
27168   }
27169   jresult = result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEvent_IsAltModifier(void * jarg1) {
27175   unsigned int jresult ;
27176   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27177   bool result;
27178
27179   arg1 = (Dali::KeyEvent *)jarg1;
27180   {
27181     try {
27182       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27183     } catch (std::out_of_range& e) {
27184       {
27185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27186       };
27187     } catch (std::exception& e) {
27188       {
27189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27190       };
27191     } catch (...) {
27192       {
27193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27194       };
27195     }
27196   }
27197   jresult = result;
27198   return jresult;
27199 }
27200
27201
27202 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressedName_set(void * jarg1, char * jarg2) {
27203   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27204   std::string *arg2 = 0 ;
27205
27206   arg1 = (Dali::KeyEvent *)jarg1;
27207   if (!jarg2) {
27208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27209     return ;
27210   }
27211   std::string arg2_str(jarg2);
27212   arg2 = &arg2_str;
27213   if (arg1) (arg1)->keyPressedName = *arg2;
27214
27215   //argout typemap for const std::string&
27216
27217 }
27218
27219
27220 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressedName_get(void * jarg1) {
27221   char * jresult ;
27222   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27223   std::string *result = 0 ;
27224
27225   arg1 = (Dali::KeyEvent *)jarg1;
27226   result = (std::string *) & ((arg1)->keyPressedName);
27227   jresult = SWIG_csharp_string_callback(result->c_str());
27228   return jresult;
27229 }
27230
27231
27232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressed_set(void * jarg1, char * jarg2) {
27233   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27234   std::string *arg2 = 0 ;
27235
27236   arg1 = (Dali::KeyEvent *)jarg1;
27237   if (!jarg2) {
27238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27239     return ;
27240   }
27241   std::string arg2_str(jarg2);
27242   arg2 = &arg2_str;
27243   if (arg1) (arg1)->keyPressed = *arg2;
27244
27245   //argout typemap for const std::string&
27246
27247 }
27248
27249
27250 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_KeyEvent_keyPressed_get(void * jarg1) {
27251   char * jresult ;
27252   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27253   std::string *result = 0 ;
27254
27255   arg1 = (Dali::KeyEvent *)jarg1;
27256   result = (std::string *) & ((arg1)->keyPressed);
27257   jresult = SWIG_csharp_string_callback(result->c_str());
27258   return jresult;
27259 }
27260
27261
27262 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyCode_set(void * jarg1, int jarg2) {
27263   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27264   int arg2 ;
27265
27266   arg1 = (Dali::KeyEvent *)jarg1;
27267   arg2 = (int)jarg2;
27268   if (arg1) (arg1)->keyCode = arg2;
27269 }
27270
27271
27272 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_keyCode_get(void * jarg1) {
27273   int jresult ;
27274   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27275   int result;
27276
27277   arg1 = (Dali::KeyEvent *)jarg1;
27278   result = (int) ((arg1)->keyCode);
27279   jresult = result;
27280   return jresult;
27281 }
27282
27283
27284 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_keyModifier_set(void * jarg1, int jarg2) {
27285   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27286   int arg2 ;
27287
27288   arg1 = (Dali::KeyEvent *)jarg1;
27289   arg2 = (int)jarg2;
27290   if (arg1) (arg1)->keyModifier = arg2;
27291 }
27292
27293
27294 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_keyModifier_get(void * jarg1) {
27295   int jresult ;
27296   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27297   int result;
27298
27299   arg1 = (Dali::KeyEvent *)jarg1;
27300   result = (int) ((arg1)->keyModifier);
27301   jresult = result;
27302   return jresult;
27303 }
27304
27305
27306 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_time_set(void * jarg1, unsigned long jarg2) {
27307   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27308   unsigned long arg2 ;
27309
27310   arg1 = (Dali::KeyEvent *)jarg1;
27311   arg2 = (unsigned long)jarg2;
27312   if (arg1) (arg1)->time = arg2;
27313 }
27314
27315
27316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyEvent_time_get(void * jarg1) {
27317   unsigned long jresult ;
27318   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27319   unsigned long result;
27320
27321   arg1 = (Dali::KeyEvent *)jarg1;
27322   result = (unsigned long) ((arg1)->time);
27323   jresult = (unsigned long)result;
27324   return jresult;
27325 }
27326
27327
27328 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEvent_state_set(void * jarg1, int jarg2) {
27329   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27330   Dali::KeyEvent::State arg2 ;
27331
27332   arg1 = (Dali::KeyEvent *)jarg1;
27333   arg2 = (Dali::KeyEvent::State)jarg2;
27334   if (arg1) (arg1)->state = arg2;
27335 }
27336
27337
27338 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyEvent_state_get(void * jarg1) {
27339   int jresult ;
27340   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27341   Dali::KeyEvent::State result;
27342
27343   arg1 = (Dali::KeyEvent *)jarg1;
27344   result = (Dali::KeyEvent::State) ((arg1)->state);
27345   jresult = (int)result;
27346   return jresult;
27347 }
27348
27349
27350 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetector__SWIG_0() {
27351   void * jresult ;
27352   Dali::LongPressGestureDetector *result = 0 ;
27353
27354   {
27355     try {
27356       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27357     } catch (std::out_of_range& e) {
27358       {
27359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27360       };
27361     } catch (std::exception& e) {
27362       {
27363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (...) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27368       };
27369     }
27370   }
27371   jresult = (void *)result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_0() {
27377   void * jresult ;
27378   Dali::LongPressGestureDetector result;
27379
27380   {
27381     try {
27382       result = Dali::LongPressGestureDetector::New();
27383     } catch (std::out_of_range& e) {
27384       {
27385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27386       };
27387     } catch (std::exception& e) {
27388       {
27389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27390       };
27391     } catch (...) {
27392       {
27393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27394       };
27395     }
27396   }
27397   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27398   return jresult;
27399 }
27400
27401
27402 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27403   void * jresult ;
27404   unsigned int arg1 ;
27405   Dali::LongPressGestureDetector result;
27406
27407   arg1 = (unsigned int)jarg1;
27408   {
27409     try {
27410       result = Dali::LongPressGestureDetector::New(arg1);
27411     } catch (std::out_of_range& e) {
27412       {
27413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27414       };
27415     } catch (std::exception& e) {
27416       {
27417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27418       };
27419     } catch (...) {
27420       {
27421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27422       };
27423     }
27424   }
27425   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27426   return jresult;
27427 }
27428
27429
27430 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27431   void * jresult ;
27432   unsigned int arg1 ;
27433   unsigned int arg2 ;
27434   Dali::LongPressGestureDetector result;
27435
27436   arg1 = (unsigned int)jarg1;
27437   arg2 = (unsigned int)jarg2;
27438   {
27439     try {
27440       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27441     } catch (std::out_of_range& e) {
27442       {
27443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27444       };
27445     } catch (std::exception& e) {
27446       {
27447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27448       };
27449     } catch (...) {
27450       {
27451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27452       };
27453     }
27454   }
27455   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27456   return jresult;
27457 }
27458
27459
27460 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_DownCast(void * jarg1) {
27461   void * jresult ;
27462   Dali::BaseHandle arg1 ;
27463   Dali::BaseHandle *argp1 ;
27464   Dali::LongPressGestureDetector result;
27465
27466   argp1 = (Dali::BaseHandle *)jarg1;
27467   if (!argp1) {
27468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27469     return 0;
27470   }
27471   arg1 = *argp1;
27472   {
27473     try {
27474       result = Dali::LongPressGestureDetector::DownCast(arg1);
27475     } catch (std::out_of_range& e) {
27476       {
27477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27478       };
27479     } catch (std::exception& e) {
27480       {
27481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27482       };
27483     } catch (...) {
27484       {
27485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27486       };
27487     }
27488   }
27489   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27490   return jresult;
27491 }
27492
27493
27494 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGestureDetector(void * jarg1) {
27495   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27496
27497   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27498   {
27499     try {
27500       delete arg1;
27501     } catch (std::out_of_range& e) {
27502       {
27503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27504       };
27505     } catch (std::exception& e) {
27506       {
27507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27508       };
27509     } catch (...) {
27510       {
27511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27512       };
27513     }
27514   }
27515 }
27516
27517
27518 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27519   void * jresult ;
27520   Dali::LongPressGestureDetector *arg1 = 0 ;
27521   Dali::LongPressGestureDetector *result = 0 ;
27522
27523   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27524   if (!arg1) {
27525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27526     return 0;
27527   }
27528   {
27529     try {
27530       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27531     } catch (std::out_of_range& e) {
27532       {
27533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27534       };
27535     } catch (std::exception& e) {
27536       {
27537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27538       };
27539     } catch (...) {
27540       {
27541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27542       };
27543     }
27544   }
27545   jresult = (void *)result;
27546   return jresult;
27547 }
27548
27549
27550 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27551   void * jresult ;
27552   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27553   Dali::LongPressGestureDetector *arg2 = 0 ;
27554   Dali::LongPressGestureDetector *result = 0 ;
27555
27556   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27557   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27558   if (!arg2) {
27559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27560     return 0;
27561   }
27562   {
27563     try {
27564       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27565     } catch (std::out_of_range& e) {
27566       {
27567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27568       };
27569     } catch (std::exception& e) {
27570       {
27571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27572       };
27573     } catch (...) {
27574       {
27575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27576       };
27577     }
27578   }
27579   jresult = (void *)result;
27580   return jresult;
27581 }
27582
27583
27584 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27585   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27586   unsigned int arg2 ;
27587
27588   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27589   arg2 = (unsigned int)jarg2;
27590   {
27591     try {
27592       (arg1)->SetTouchesRequired(arg2);
27593     } catch (std::out_of_range& e) {
27594       {
27595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27596       };
27597     } catch (std::exception& e) {
27598       {
27599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27600       };
27601     } catch (...) {
27602       {
27603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27604       };
27605     }
27606   }
27607 }
27608
27609
27610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27611   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27612   unsigned int arg2 ;
27613   unsigned int arg3 ;
27614
27615   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27616   arg2 = (unsigned int)jarg2;
27617   arg3 = (unsigned int)jarg3;
27618   {
27619     try {
27620       (arg1)->SetTouchesRequired(arg2,arg3);
27621     } catch (std::out_of_range& e) {
27622       {
27623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27624       };
27625     } catch (std::exception& e) {
27626       {
27627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27628       };
27629     } catch (...) {
27630       {
27631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27632       };
27633     }
27634   }
27635 }
27636
27637
27638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27639   unsigned int jresult ;
27640   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27641   unsigned int result;
27642
27643   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27644   {
27645     try {
27646       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27647     } catch (std::out_of_range& e) {
27648       {
27649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27650       };
27651     } catch (std::exception& e) {
27652       {
27653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27654       };
27655     } catch (...) {
27656       {
27657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27658       };
27659     }
27660   }
27661   jresult = result;
27662   return jresult;
27663 }
27664
27665
27666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27667   unsigned int jresult ;
27668   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27669   unsigned int result;
27670
27671   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27672   {
27673     try {
27674       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27675     } catch (std::out_of_range& e) {
27676       {
27677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27678       };
27679     } catch (std::exception& e) {
27680       {
27681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27686       };
27687     }
27688   }
27689   jresult = result;
27690   return jresult;
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27695   void * jresult ;
27696   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27697   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27698
27699   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27700   {
27701     try {
27702       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27703     } catch (std::out_of_range& e) {
27704       {
27705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27706       };
27707     } catch (std::exception& e) {
27708       {
27709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27710       };
27711     } catch (...) {
27712       {
27713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27714       };
27715     }
27716   }
27717   jresult = (void *)result;
27718   return jresult;
27719 }
27720
27721
27722 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGesture__SWIG_0(int jarg1) {
27723   void * jresult ;
27724   Dali::Gesture::State arg1 ;
27725   Dali::LongPressGesture *result = 0 ;
27726
27727   arg1 = (Dali::Gesture::State)jarg1;
27728   {
27729     try {
27730       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27731     } catch (std::out_of_range& e) {
27732       {
27733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27734       };
27735     } catch (std::exception& e) {
27736       {
27737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27738       };
27739     } catch (...) {
27740       {
27741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27742       };
27743     }
27744   }
27745   jresult = (void *)result;
27746   return jresult;
27747 }
27748
27749
27750 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGesture__SWIG_1(void * jarg1) {
27751   void * jresult ;
27752   Dali::LongPressGesture *arg1 = 0 ;
27753   Dali::LongPressGesture *result = 0 ;
27754
27755   arg1 = (Dali::LongPressGesture *)jarg1;
27756   if (!arg1) {
27757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27758     return 0;
27759   }
27760   {
27761     try {
27762       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27763     } catch (std::out_of_range& e) {
27764       {
27765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (std::exception& e) {
27768       {
27769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27770       };
27771     } catch (...) {
27772       {
27773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27774       };
27775     }
27776   }
27777   jresult = (void *)result;
27778   return jresult;
27779 }
27780
27781
27782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27783   void * jresult ;
27784   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27785   Dali::LongPressGesture *arg2 = 0 ;
27786   Dali::LongPressGesture *result = 0 ;
27787
27788   arg1 = (Dali::LongPressGesture *)jarg1;
27789   arg2 = (Dali::LongPressGesture *)jarg2;
27790   if (!arg2) {
27791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27792     return 0;
27793   }
27794   {
27795     try {
27796       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27797     } catch (std::out_of_range& e) {
27798       {
27799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27800       };
27801     } catch (std::exception& e) {
27802       {
27803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27804       };
27805     } catch (...) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27808       };
27809     }
27810   }
27811   jresult = (void *)result;
27812   return jresult;
27813 }
27814
27815
27816 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGesture(void * jarg1) {
27817   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27818
27819   arg1 = (Dali::LongPressGesture *)jarg1;
27820   {
27821     try {
27822       delete arg1;
27823     } catch (std::out_of_range& e) {
27824       {
27825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27826       };
27827     } catch (std::exception& e) {
27828       {
27829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27830       };
27831     } catch (...) {
27832       {
27833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27834       };
27835     }
27836   }
27837 }
27838
27839
27840 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
27841   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27842   unsigned int arg2 ;
27843
27844   arg1 = (Dali::LongPressGesture *)jarg1;
27845   arg2 = (unsigned int)jarg2;
27846   if (arg1) (arg1)->numberOfTouches = arg2;
27847 }
27848
27849
27850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGesture_numberOfTouches_get(void * jarg1) {
27851   unsigned int jresult ;
27852   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27853   unsigned int result;
27854
27855   arg1 = (Dali::LongPressGesture *)jarg1;
27856   result = (unsigned int) ((arg1)->numberOfTouches);
27857   jresult = result;
27858   return jresult;
27859 }
27860
27861
27862 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
27863   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27864   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27865
27866   arg1 = (Dali::LongPressGesture *)jarg1;
27867   arg2 = (Dali::Vector2 *)jarg2;
27868   if (arg1) (arg1)->screenPoint = *arg2;
27869 }
27870
27871
27872 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_screenPoint_get(void * jarg1) {
27873   void * jresult ;
27874   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27875   Dali::Vector2 *result = 0 ;
27876
27877   arg1 = (Dali::LongPressGesture *)jarg1;
27878   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
27879   jresult = (void *)result;
27880   return jresult;
27881 }
27882
27883
27884 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
27885   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27886   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27887
27888   arg1 = (Dali::LongPressGesture *)jarg1;
27889   arg2 = (Dali::Vector2 *)jarg2;
27890   if (arg1) (arg1)->localPoint = *arg2;
27891 }
27892
27893
27894 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LongPressGesture_localPoint_get(void * jarg1) {
27895   void * jresult ;
27896   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27897   Dali::Vector2 *result = 0 ;
27898
27899   arg1 = (Dali::LongPressGesture *)jarg1;
27900   result = (Dali::Vector2 *)& ((arg1)->localPoint);
27901   jresult = (void *)result;
27902   return jresult;
27903 }
27904
27905
27906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_WheelEvent__SWIG_0() {
27907   void * jresult ;
27908   Dali::WheelEvent *result = 0 ;
27909
27910   {
27911     try {
27912       result = (Dali::WheelEvent *)new Dali::WheelEvent();
27913     } catch (std::out_of_range& e) {
27914       {
27915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27916       };
27917     } catch (std::exception& e) {
27918       {
27919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27920       };
27921     } catch (...) {
27922       {
27923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27924       };
27925     }
27926   }
27927   jresult = (void *)result;
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_WheelEvent__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
27933   void * jresult ;
27934   Dali::WheelEvent::Type arg1 ;
27935   int arg2 ;
27936   unsigned int arg3 ;
27937   Dali::Vector2 arg4 ;
27938   int arg5 ;
27939   unsigned int arg6 ;
27940   Dali::Vector2 *argp4 ;
27941   Dali::WheelEvent *result = 0 ;
27942
27943   arg1 = (Dali::WheelEvent::Type)jarg1;
27944   arg2 = (int)jarg2;
27945   arg3 = (unsigned int)jarg3;
27946   argp4 = (Dali::Vector2 *)jarg4;
27947   if (!argp4) {
27948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
27949     return 0;
27950   }
27951   arg4 = *argp4;
27952   arg5 = (int)jarg5;
27953   arg6 = (unsigned int)jarg6;
27954   {
27955     try {
27956       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_WheelEvent(void * jarg1) {
27977   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
27978
27979   arg1 = (Dali::WheelEvent *)jarg1;
27980   {
27981     try {
27982       delete arg1;
27983     } catch (std::out_of_range& e) {
27984       {
27985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27986       };
27987     } catch (std::exception& e) {
27988       {
27989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27990       };
27991     } catch (...) {
27992       {
27993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27994       };
27995     }
27996   }
27997 }
27998
27999
28000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsShiftModifier(void * jarg1) {
28001   unsigned int jresult ;
28002   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28003   bool result;
28004
28005   arg1 = (Dali::WheelEvent *)jarg1;
28006   {
28007     try {
28008       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28009     } catch (std::out_of_range& e) {
28010       {
28011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (std::exception& e) {
28014       {
28015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28016       };
28017     } catch (...) {
28018       {
28019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28020       };
28021     }
28022   }
28023   jresult = result;
28024   return jresult;
28025 }
28026
28027
28028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsCtrlModifier(void * jarg1) {
28029   unsigned int jresult ;
28030   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28031   bool result;
28032
28033   arg1 = (Dali::WheelEvent *)jarg1;
28034   {
28035     try {
28036       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28037     } catch (std::out_of_range& e) {
28038       {
28039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28040       };
28041     } catch (std::exception& e) {
28042       {
28043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28044       };
28045     } catch (...) {
28046       {
28047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28048       };
28049     }
28050   }
28051   jresult = result;
28052   return jresult;
28053 }
28054
28055
28056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_IsAltModifier(void * jarg1) {
28057   unsigned int jresult ;
28058   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28059   bool result;
28060
28061   arg1 = (Dali::WheelEvent *)jarg1;
28062   {
28063     try {
28064       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28065     } catch (std::out_of_range& e) {
28066       {
28067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28068       };
28069     } catch (std::exception& e) {
28070       {
28071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28072       };
28073     } catch (...) {
28074       {
28075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28076       };
28077     }
28078   }
28079   jresult = result;
28080   return jresult;
28081 }
28082
28083
28084 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_type_set(void * jarg1, int jarg2) {
28085   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28086   Dali::WheelEvent::Type arg2 ;
28087
28088   arg1 = (Dali::WheelEvent *)jarg1;
28089   arg2 = (Dali::WheelEvent::Type)jarg2;
28090   if (arg1) (arg1)->type = arg2;
28091 }
28092
28093
28094 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_type_get(void * jarg1) {
28095   int jresult ;
28096   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28097   Dali::WheelEvent::Type result;
28098
28099   arg1 = (Dali::WheelEvent *)jarg1;
28100   result = (Dali::WheelEvent::Type) ((arg1)->type);
28101   jresult = (int)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_direction_set(void * jarg1, int jarg2) {
28107   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28108   int arg2 ;
28109
28110   arg1 = (Dali::WheelEvent *)jarg1;
28111   arg2 = (int)jarg2;
28112   if (arg1) (arg1)->direction = arg2;
28113 }
28114
28115
28116 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_direction_get(void * jarg1) {
28117   int jresult ;
28118   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28119   int result;
28120
28121   arg1 = (Dali::WheelEvent *)jarg1;
28122   result = (int) ((arg1)->direction);
28123   jresult = result;
28124   return jresult;
28125 }
28126
28127
28128 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_modifiers_set(void * jarg1, unsigned int jarg2) {
28129   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28130   unsigned int arg2 ;
28131
28132   arg1 = (Dali::WheelEvent *)jarg1;
28133   arg2 = (unsigned int)jarg2;
28134   if (arg1) (arg1)->modifiers = arg2;
28135 }
28136
28137
28138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_modifiers_get(void * jarg1) {
28139   unsigned int jresult ;
28140   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28141   unsigned int result;
28142
28143   arg1 = (Dali::WheelEvent *)jarg1;
28144   result = (unsigned int) ((arg1)->modifiers);
28145   jresult = result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_point_set(void * jarg1, void * jarg2) {
28151   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28152   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28153
28154   arg1 = (Dali::WheelEvent *)jarg1;
28155   arg2 = (Dali::Vector2 *)jarg2;
28156   if (arg1) (arg1)->point = *arg2;
28157 }
28158
28159
28160 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_WheelEvent_point_get(void * jarg1) {
28161   void * jresult ;
28162   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28163   Dali::Vector2 *result = 0 ;
28164
28165   arg1 = (Dali::WheelEvent *)jarg1;
28166   result = (Dali::Vector2 *)& ((arg1)->point);
28167   jresult = (void *)result;
28168   return jresult;
28169 }
28170
28171
28172 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_z_set(void * jarg1, int jarg2) {
28173   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28174   int arg2 ;
28175
28176   arg1 = (Dali::WheelEvent *)jarg1;
28177   arg2 = (int)jarg2;
28178   if (arg1) (arg1)->z = arg2;
28179 }
28180
28181
28182 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_WheelEvent_z_get(void * jarg1) {
28183   int jresult ;
28184   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28185   int result;
28186
28187   arg1 = (Dali::WheelEvent *)jarg1;
28188   result = (int) ((arg1)->z);
28189   jresult = result;
28190   return jresult;
28191 }
28192
28193
28194 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WheelEvent_timeStamp_set(void * jarg1, unsigned int jarg2) {
28195   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28196   unsigned int arg2 ;
28197
28198   arg1 = (Dali::WheelEvent *)jarg1;
28199   arg2 = (unsigned int)jarg2;
28200   if (arg1) (arg1)->timeStamp = arg2;
28201 }
28202
28203
28204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_WheelEvent_timeStamp_get(void * jarg1) {
28205   unsigned int jresult ;
28206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28207   unsigned int result;
28208
28209   arg1 = (Dali::WheelEvent *)jarg1;
28210   result = (unsigned int) ((arg1)->timeStamp);
28211   jresult = result;
28212   return jresult;
28213 }
28214
28215
28216 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_get() {
28217   int jresult ;
28218   int result;
28219
28220   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28221   jresult = (int)result;
28222   return jresult;
28223 }
28224
28225
28226 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_X_get() {
28227   int jresult ;
28228   int result;
28229
28230   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28231   jresult = (int)result;
28232   return jresult;
28233 }
28234
28235
28236 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_Y_get() {
28237   int jresult ;
28238   int result;
28239
28240   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28241   jresult = (int)result;
28242   return jresult;
28243 }
28244
28245
28246 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PARENT_ORIGIN_Z_get() {
28247   int jresult ;
28248   int result;
28249
28250   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28251   jresult = (int)result;
28252   return jresult;
28253 }
28254
28255
28256 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_get() {
28257   int jresult ;
28258   int result;
28259
28260   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28261   jresult = (int)result;
28262   return jresult;
28263 }
28264
28265
28266 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_X_get() {
28267   int jresult ;
28268   int result;
28269
28270   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28271   jresult = (int)result;
28272   return jresult;
28273 }
28274
28275
28276 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_Y_get() {
28277   int jresult ;
28278   int result;
28279
28280   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28281   jresult = (int)result;
28282   return jresult;
28283 }
28284
28285
28286 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ANCHOR_POINT_Z_get() {
28287   int jresult ;
28288   int result;
28289
28290   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28291   jresult = (int)result;
28292   return jresult;
28293 }
28294
28295
28296 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_get() {
28297   int jresult ;
28298   int result;
28299
28300   result = (int)Dali::Actor::Property::SIZE;
28301   jresult = (int)result;
28302   return jresult;
28303 }
28304
28305
28306 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_WIDTH_get() {
28307   int jresult ;
28308   int result;
28309
28310   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28311   jresult = (int)result;
28312   return jresult;
28313 }
28314
28315
28316 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_HEIGHT_get() {
28317   int jresult ;
28318   int result;
28319
28320   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28321   jresult = (int)result;
28322   return jresult;
28323 }
28324
28325
28326 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_DEPTH_get() {
28327   int jresult ;
28328   int result;
28329
28330   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28331   jresult = (int)result;
28332   return jresult;
28333 }
28334
28335
28336 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_get() {
28337   int jresult ;
28338   int result;
28339
28340   result = (int)Dali::Actor::Property::POSITION;
28341   jresult = (int)result;
28342   return jresult;
28343 }
28344
28345
28346 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_X_get() {
28347   int jresult ;
28348   int result;
28349
28350   result = (int)Dali::Actor::Property::POSITION_X;
28351   jresult = (int)result;
28352   return jresult;
28353 }
28354
28355
28356 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_Y_get() {
28357   int jresult ;
28358   int result;
28359
28360   result = (int)Dali::Actor::Property::POSITION_Y;
28361   jresult = (int)result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_Z_get() {
28367   int jresult ;
28368   int result;
28369
28370   result = (int)Dali::Actor::Property::POSITION_Z;
28371   jresult = (int)result;
28372   return jresult;
28373 }
28374
28375
28376 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_get() {
28377   int jresult ;
28378   int result;
28379
28380   result = (int)Dali::Actor::Property::WORLD_POSITION;
28381   jresult = (int)result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_X_get() {
28387   int jresult ;
28388   int result;
28389
28390   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28391   jresult = (int)result;
28392   return jresult;
28393 }
28394
28395
28396 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_Y_get() {
28397   int jresult ;
28398   int result;
28399
28400   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28401   jresult = (int)result;
28402   return jresult;
28403 }
28404
28405
28406 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_POSITION_Z_get() {
28407   int jresult ;
28408   int result;
28409
28410   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28411   jresult = (int)result;
28412   return jresult;
28413 }
28414
28415
28416 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_ORIENTATION_get() {
28417   int jresult ;
28418   int result;
28419
28420   result = (int)Dali::Actor::Property::ORIENTATION;
28421   jresult = (int)result;
28422   return jresult;
28423 }
28424
28425
28426 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_ORIENTATION_get() {
28427   int jresult ;
28428   int result;
28429
28430   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28431   jresult = (int)result;
28432   return jresult;
28433 }
28434
28435
28436 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_get() {
28437   int jresult ;
28438   int result;
28439
28440   result = (int)Dali::Actor::Property::SCALE;
28441   jresult = (int)result;
28442   return jresult;
28443 }
28444
28445
28446 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_X_get() {
28447   int jresult ;
28448   int result;
28449
28450   result = (int)Dali::Actor::Property::SCALE_X;
28451   jresult = (int)result;
28452   return jresult;
28453 }
28454
28455
28456 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_Y_get() {
28457   int jresult ;
28458   int result;
28459
28460   result = (int)Dali::Actor::Property::SCALE_Y;
28461   jresult = (int)result;
28462   return jresult;
28463 }
28464
28465
28466 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SCALE_Z_get() {
28467   int jresult ;
28468   int result;
28469
28470   result = (int)Dali::Actor::Property::SCALE_Z;
28471   jresult = (int)result;
28472   return jresult;
28473 }
28474
28475
28476 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_SCALE_get() {
28477   int jresult ;
28478   int result;
28479
28480   result = (int)Dali::Actor::Property::WORLD_SCALE;
28481   jresult = (int)result;
28482   return jresult;
28483 }
28484
28485
28486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_VISIBLE_get() {
28487   int jresult ;
28488   int result;
28489
28490   result = (int)Dali::Actor::Property::VISIBLE;
28491   jresult = (int)result;
28492   return jresult;
28493 }
28494
28495
28496 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_get() {
28497   int jresult ;
28498   int result;
28499
28500   result = (int)Dali::Actor::Property::COLOR;
28501   jresult = (int)result;
28502   return jresult;
28503 }
28504
28505
28506 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_RED_get() {
28507   int jresult ;
28508   int result;
28509
28510   result = (int)Dali::Actor::Property::COLOR_RED;
28511   jresult = (int)result;
28512   return jresult;
28513 }
28514
28515
28516 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_GREEN_get() {
28517   int jresult ;
28518   int result;
28519
28520   result = (int)Dali::Actor::Property::COLOR_GREEN;
28521   jresult = (int)result;
28522   return jresult;
28523 }
28524
28525
28526 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_BLUE_get() {
28527   int jresult ;
28528   int result;
28529
28530   result = (int)Dali::Actor::Property::COLOR_BLUE;
28531   jresult = (int)result;
28532   return jresult;
28533 }
28534
28535
28536 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_ALPHA_get() {
28537   int jresult ;
28538   int result;
28539
28540   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28541   jresult = (int)result;
28542   return jresult;
28543 }
28544
28545
28546 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_COLOR_get() {
28547   int jresult ;
28548   int result;
28549
28550   result = (int)Dali::Actor::Property::WORLD_COLOR;
28551   jresult = (int)result;
28552   return jresult;
28553 }
28554
28555
28556 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WORLD_MATRIX_get() {
28557   int jresult ;
28558   int result;
28559
28560   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28561   jresult = (int)result;
28562   return jresult;
28563 }
28564
28565
28566 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_NAME_get() {
28567   int jresult ;
28568   int result;
28569
28570   result = (int)Dali::Actor::Property::NAME;
28571   jresult = (int)result;
28572   return jresult;
28573 }
28574
28575
28576 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SENSITIVE_get() {
28577   int jresult ;
28578   int result;
28579
28580   result = (int)Dali::Actor::Property::SENSITIVE;
28581   jresult = (int)result;
28582   return jresult;
28583 }
28584
28585
28586 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_LEAVE_REQUIRED_get() {
28587   int jresult ;
28588   int result;
28589
28590   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28591   jresult = (int)result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_ORIENTATION_get() {
28597   int jresult ;
28598   int result;
28599
28600   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28601   jresult = (int)result;
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_SCALE_get() {
28607   int jresult ;
28608   int result;
28609
28610   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28611   jresult = (int)result;
28612   return jresult;
28613 }
28614
28615
28616 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_COLOR_MODE_get() {
28617   int jresult ;
28618   int result;
28619
28620   result = (int)Dali::Actor::Property::COLOR_MODE;
28621   jresult = (int)result;
28622   return jresult;
28623 }
28624
28625
28626 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_POSITION_INHERITANCE_get() {
28627   int jresult ;
28628   int result;
28629
28630   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28631   jresult = (int)result;
28632   return jresult;
28633 }
28634
28635
28636 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_DRAW_MODE_get() {
28637   int jresult ;
28638   int result;
28639
28640   result = (int)Dali::Actor::Property::DRAW_MODE;
28641   jresult = (int)result;
28642   return jresult;
28643 }
28644
28645
28646 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_MODE_FACTOR_get() {
28647   int jresult ;
28648   int result;
28649
28650   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28651   jresult = (int)result;
28652   return jresult;
28653 }
28654
28655
28656 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28657   int jresult ;
28658   int result;
28659
28660   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28661   jresult = (int)result;
28662   return jresult;
28663 }
28664
28665
28666 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28667   int jresult ;
28668   int result;
28669
28670   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28671   jresult = (int)result;
28672   return jresult;
28673 }
28674
28675
28676 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_SIZE_SCALE_POLICY_get() {
28677   int jresult ;
28678   int result;
28679
28680   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28681   jresult = (int)result;
28682   return jresult;
28683 }
28684
28685
28686 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28687   int jresult ;
28688   int result;
28689
28690   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28691   jresult = (int)result;
28692   return jresult;
28693 }
28694
28695
28696 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28697   int jresult ;
28698   int result;
28699
28700   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28701   jresult = (int)result;
28702   return jresult;
28703 }
28704
28705
28706 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_PADDING_get() {
28707   int jresult ;
28708   int result;
28709
28710   result = (int)Dali::Actor::Property::PADDING;
28711   jresult = (int)result;
28712   return jresult;
28713 }
28714
28715
28716 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_MINIMUM_SIZE_get() {
28717   int jresult ;
28718   int result;
28719
28720   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28721   jresult = (int)result;
28722   return jresult;
28723 }
28724
28725
28726 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_MAXIMUM_SIZE_get() {
28727   int jresult ;
28728   int result;
28729
28730   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28731   jresult = (int)result;
28732   return jresult;
28733 }
28734
28735
28736 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_INHERIT_POSITION_get() {
28737   int jresult ;
28738   int result;
28739
28740   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28741   jresult = (int)result;
28742   return jresult;
28743 }
28744
28745
28746 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_Property_CLIPPING_MODE_get() {
28747   int jresult ;
28748   int result;
28749
28750   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28751   jresult = (int)result;
28752   return jresult;
28753 }
28754
28755
28756 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor_Property() {
28757   void * jresult ;
28758   Dali::Actor::Property *result = 0 ;
28759
28760   {
28761     try {
28762       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28763     } catch (std::out_of_range& e) {
28764       {
28765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28766       };
28767     } catch (std::exception& e) {
28768       {
28769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28770       };
28771     } catch (...) {
28772       {
28773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28774       };
28775     }
28776   }
28777   jresult = (void *)result;
28778   return jresult;
28779 }
28780
28781
28782 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Actor_Property(void * jarg1) {
28783   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28784
28785   arg1 = (Dali::Actor::Property *)jarg1;
28786   {
28787     try {
28788       delete arg1;
28789     } catch (std::out_of_range& e) {
28790       {
28791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28792       };
28793     } catch (std::exception& e) {
28794       {
28795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28796       };
28797     } catch (...) {
28798       {
28799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28800       };
28801     }
28802   }
28803 }
28804
28805
28806 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor__SWIG_0() {
28807   void * jresult ;
28808   Dali::Actor *result = 0 ;
28809
28810   {
28811     try {
28812       result = (Dali::Actor *)new Dali::Actor();
28813     } catch (std::out_of_range& e) {
28814       {
28815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28816       };
28817     } catch (std::exception& e) {
28818       {
28819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28820       };
28821     } catch (...) {
28822       {
28823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28824       };
28825     }
28826   }
28827   jresult = (void *)result;
28828   return jresult;
28829 }
28830
28831
28832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_New() {
28833   void * jresult ;
28834   Dali::Actor result;
28835
28836   {
28837     try {
28838       result = Dali::Actor::New();
28839     } catch (std::out_of_range& e) {
28840       {
28841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28842       };
28843     } catch (std::exception& e) {
28844       {
28845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28846       };
28847     } catch (...) {
28848       {
28849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28850       };
28851     }
28852   }
28853   jresult = new Dali::Actor((const Dali::Actor &)result);
28854   return jresult;
28855 }
28856
28857
28858 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_DownCast(void * jarg1) {
28859   void * jresult ;
28860   Dali::BaseHandle arg1 ;
28861   Dali::BaseHandle *argp1 ;
28862   Dali::Actor result;
28863
28864   argp1 = (Dali::BaseHandle *)jarg1;
28865   if (!argp1) {
28866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28867     return 0;
28868   }
28869   arg1 = *argp1;
28870   {
28871     try {
28872       result = Dali::Actor::DownCast(arg1);
28873     } catch (std::out_of_range& e) {
28874       {
28875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28876       };
28877     } catch (std::exception& e) {
28878       {
28879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28880       };
28881     } catch (...) {
28882       {
28883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28884       };
28885     }
28886   }
28887   jresult = new Dali::Actor((const Dali::Actor &)result);
28888   return jresult;
28889 }
28890
28891
28892 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Actor(void * jarg1) {
28893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28894
28895   arg1 = (Dali::Actor *)jarg1;
28896   {
28897     try {
28898       delete arg1;
28899     } catch (std::out_of_range& e) {
28900       {
28901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28902       };
28903     } catch (std::exception& e) {
28904       {
28905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28906       };
28907     } catch (...) {
28908       {
28909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28910       };
28911     }
28912   }
28913 }
28914
28915
28916 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Actor__SWIG_1(void * jarg1) {
28917   void * jresult ;
28918   Dali::Actor *arg1 = 0 ;
28919   Dali::Actor *result = 0 ;
28920
28921   arg1 = (Dali::Actor *)jarg1;
28922   if (!arg1) {
28923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28924     return 0;
28925   }
28926   {
28927     try {
28928       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
28929     } catch (std::out_of_range& e) {
28930       {
28931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28932       };
28933     } catch (std::exception& e) {
28934       {
28935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28936       };
28937     } catch (...) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28940       };
28941     }
28942   }
28943   jresult = (void *)result;
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_Assign(void * jarg1, void * jarg2) {
28949   void * jresult ;
28950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28951   Dali::Actor *arg2 = 0 ;
28952   Dali::Actor *result = 0 ;
28953
28954   arg1 = (Dali::Actor *)jarg1;
28955   arg2 = (Dali::Actor *)jarg2;
28956   if (!arg2) {
28957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28958     return 0;
28959   }
28960   {
28961     try {
28962       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28974       };
28975     }
28976   }
28977   jresult = (void *)result;
28978   return jresult;
28979 }
28980
28981
28982 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Actor_GetName(void * jarg1) {
28983   char * jresult ;
28984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
28985   std::string *result = 0 ;
28986
28987   arg1 = (Dali::Actor *)jarg1;
28988   {
28989     try {
28990       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
28991     } catch (std::out_of_range& e) {
28992       {
28993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28994       };
28995     } catch (std::exception& e) {
28996       {
28997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (...) {
29000       {
29001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29002       };
29003     }
29004   }
29005   jresult = SWIG_csharp_string_callback(result->c_str());
29006   return jresult;
29007 }
29008
29009
29010 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetName(void * jarg1, char * jarg2) {
29011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29012   std::string *arg2 = 0 ;
29013
29014   arg1 = (Dali::Actor *)jarg1;
29015   if (!jarg2) {
29016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29017     return ;
29018   }
29019   std::string arg2_str(jarg2);
29020   arg2 = &arg2_str;
29021   {
29022     try {
29023       (arg1)->SetName((std::string const &)*arg2);
29024     } catch (std::out_of_range& e) {
29025       {
29026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29027       };
29028     } catch (std::exception& e) {
29029       {
29030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29031       };
29032     } catch (...) {
29033       {
29034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29035       };
29036     }
29037   }
29038
29039   //argout typemap for const std::string&
29040
29041 }
29042
29043
29044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetId(void * jarg1) {
29045   unsigned int jresult ;
29046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29047   unsigned int result;
29048
29049   arg1 = (Dali::Actor *)jarg1;
29050   {
29051     try {
29052       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29053     } catch (std::out_of_range& e) {
29054       {
29055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29056       };
29057     } catch (std::exception& e) {
29058       {
29059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29060       };
29061     } catch (...) {
29062       {
29063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29064       };
29065     }
29066   }
29067   jresult = result;
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsRoot(void * jarg1) {
29073   unsigned int jresult ;
29074   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29075   bool result;
29076
29077   arg1 = (Dali::Actor *)jarg1;
29078   {
29079     try {
29080       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29081     } catch (std::out_of_range& e) {
29082       {
29083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29084       };
29085     } catch (std::exception& e) {
29086       {
29087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29088       };
29089     } catch (...) {
29090       {
29091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29092       };
29093     }
29094   }
29095   jresult = result;
29096   return jresult;
29097 }
29098
29099
29100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_OnStage(void * jarg1) {
29101   unsigned int jresult ;
29102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29103   bool result;
29104
29105   arg1 = (Dali::Actor *)jarg1;
29106   {
29107     try {
29108       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29109     } catch (std::out_of_range& e) {
29110       {
29111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29112       };
29113     } catch (std::exception& e) {
29114       {
29115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29116       };
29117     } catch (...) {
29118       {
29119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29120       };
29121     }
29122   }
29123   jresult = result;
29124   return jresult;
29125 }
29126
29127
29128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsLayer(void * jarg1) {
29129   unsigned int jresult ;
29130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29131   bool result;
29132
29133   arg1 = (Dali::Actor *)jarg1;
29134   {
29135     try {
29136       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29137     } catch (std::out_of_range& e) {
29138       {
29139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29140       };
29141     } catch (std::exception& e) {
29142       {
29143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29144       };
29145     } catch (...) {
29146       {
29147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29148       };
29149     }
29150   }
29151   jresult = result;
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetLayer(void * jarg1) {
29157   void * jresult ;
29158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29159   Dali::Layer result;
29160
29161   arg1 = (Dali::Actor *)jarg1;
29162   {
29163     try {
29164       result = (arg1)->GetLayer();
29165     } catch (std::out_of_range& e) {
29166       {
29167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29168       };
29169     } catch (std::exception& e) {
29170       {
29171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29172       };
29173     } catch (...) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29176       };
29177     }
29178   }
29179   jresult = new Dali::Layer((const Dali::Layer &)result);
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Add(void * jarg1, void * jarg2) {
29185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29186   Dali::Actor arg2 ;
29187   Dali::Actor *argp2 ;
29188
29189   arg1 = (Dali::Actor *)jarg1;
29190   argp2 = (Dali::Actor *)jarg2;
29191   if (!argp2) {
29192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29193     return ;
29194   }
29195   arg2 = *argp2;
29196   {
29197     try {
29198       (arg1)->Add(arg2);
29199     } catch (std::out_of_range& e) {
29200       {
29201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29202       };
29203     } catch (std::exception& e) {
29204       {
29205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29206       };
29207     } catch (...) {
29208       {
29209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29210       };
29211     }
29212   }
29213 }
29214
29215
29216 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Remove(void * jarg1, void * jarg2) {
29217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29218   Dali::Actor arg2 ;
29219   Dali::Actor *argp2 ;
29220
29221   arg1 = (Dali::Actor *)jarg1;
29222   argp2 = (Dali::Actor *)jarg2;
29223   if (!argp2) {
29224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29225     return ;
29226   }
29227   arg2 = *argp2;
29228   {
29229     try {
29230       (arg1)->Remove(arg2);
29231     } catch (std::out_of_range& e) {
29232       {
29233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29234       };
29235     } catch (std::exception& e) {
29236       {
29237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29242       };
29243     }
29244   }
29245 }
29246
29247
29248 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_Unparent(void * jarg1) {
29249   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29250
29251   arg1 = (Dali::Actor *)jarg1;
29252   {
29253     try {
29254       (arg1)->Unparent();
29255     } catch (std::out_of_range& e) {
29256       {
29257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29258       };
29259     } catch (std::exception& e) {
29260       {
29261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29262       };
29263     } catch (...) {
29264       {
29265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29266       };
29267     }
29268   }
29269 }
29270
29271
29272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetChildCount(void * jarg1) {
29273   unsigned int jresult ;
29274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29275   unsigned int result;
29276
29277   arg1 = (Dali::Actor *)jarg1;
29278   {
29279     try {
29280       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29281     } catch (std::out_of_range& e) {
29282       {
29283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29284       };
29285     } catch (std::exception& e) {
29286       {
29287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29288       };
29289     } catch (...) {
29290       {
29291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29292       };
29293     }
29294   }
29295   jresult = result;
29296   return jresult;
29297 }
29298
29299
29300 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29301   void * jresult ;
29302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29303   unsigned int arg2 ;
29304   Dali::Actor result;
29305
29306   arg1 = (Dali::Actor *)jarg1;
29307   arg2 = (unsigned int)jarg2;
29308   {
29309     try {
29310       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29311     } catch (std::out_of_range& e) {
29312       {
29313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29314       };
29315     } catch (std::exception& e) {
29316       {
29317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29318       };
29319     } catch (...) {
29320       {
29321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29322       };
29323     }
29324   }
29325   jresult = new Dali::Actor((const Dali::Actor &)result);
29326   return jresult;
29327 }
29328
29329
29330 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_FindChildByName(void * jarg1, char * jarg2) {
29331   void * jresult ;
29332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29333   std::string *arg2 = 0 ;
29334   Dali::Actor result;
29335
29336   arg1 = (Dali::Actor *)jarg1;
29337   if (!jarg2) {
29338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29339     return 0;
29340   }
29341   std::string arg2_str(jarg2);
29342   arg2 = &arg2_str;
29343   {
29344     try {
29345       result = (arg1)->FindChildByName((std::string const &)*arg2);
29346     } catch (std::out_of_range& e) {
29347       {
29348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29349       };
29350     } catch (std::exception& e) {
29351       {
29352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29353       };
29354     } catch (...) {
29355       {
29356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29357       };
29358     }
29359   }
29360   jresult = new Dali::Actor((const Dali::Actor &)result);
29361
29362   //argout typemap for const std::string&
29363
29364   return jresult;
29365 }
29366
29367
29368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29369   void * jresult ;
29370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29371   unsigned int arg2 ;
29372   Dali::Actor result;
29373
29374   arg1 = (Dali::Actor *)jarg1;
29375   arg2 = (unsigned int)jarg2;
29376   {
29377     try {
29378       result = (arg1)->FindChildById(arg2);
29379     } catch (std::out_of_range& e) {
29380       {
29381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29382       };
29383     } catch (std::exception& e) {
29384       {
29385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29386       };
29387     } catch (...) {
29388       {
29389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29390       };
29391     }
29392   }
29393   jresult = new Dali::Actor((const Dali::Actor &)result);
29394   return jresult;
29395 }
29396
29397
29398 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetParent(void * jarg1) {
29399   void * jresult ;
29400   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29401   Dali::Actor result;
29402
29403   arg1 = (Dali::Actor *)jarg1;
29404   {
29405     try {
29406       result = ((Dali::Actor const *)arg1)->GetParent();
29407     } catch (std::out_of_range& e) {
29408       {
29409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29410       };
29411     } catch (std::exception& e) {
29412       {
29413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29414       };
29415     } catch (...) {
29416       {
29417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29418       };
29419     }
29420   }
29421   jresult = new Dali::Actor((const Dali::Actor &)result);
29422   return jresult;
29423 }
29424
29425
29426 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29428   Dali::Vector3 *arg2 = 0 ;
29429
29430   arg1 = (Dali::Actor *)jarg1;
29431   arg2 = (Dali::Vector3 *)jarg2;
29432   if (!arg2) {
29433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29434     return ;
29435   }
29436   {
29437     try {
29438       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29439     } catch (std::out_of_range& e) {
29440       {
29441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29442       };
29443     } catch (std::exception& e) {
29444       {
29445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29446       };
29447     } catch (...) {
29448       {
29449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29450       };
29451     }
29452   }
29453 }
29454
29455
29456 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentParentOrigin(void * jarg1) {
29457   void * jresult ;
29458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29459   Dali::Vector3 result;
29460
29461   arg1 = (Dali::Actor *)jarg1;
29462   {
29463     try {
29464       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29465     } catch (std::out_of_range& e) {
29466       {
29467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29468       };
29469     } catch (std::exception& e) {
29470       {
29471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29472       };
29473     } catch (...) {
29474       {
29475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29476       };
29477     }
29478   }
29479   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29480   return jresult;
29481 }
29482
29483
29484 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29486   Dali::Vector3 *arg2 = 0 ;
29487
29488   arg1 = (Dali::Actor *)jarg1;
29489   arg2 = (Dali::Vector3 *)jarg2;
29490   if (!arg2) {
29491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29492     return ;
29493   }
29494   {
29495     try {
29496       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29508       };
29509     }
29510   }
29511 }
29512
29513
29514 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentAnchorPoint(void * jarg1) {
29515   void * jresult ;
29516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29517   Dali::Vector3 result;
29518
29519   arg1 = (Dali::Actor *)jarg1;
29520   {
29521     try {
29522       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29523     } catch (std::out_of_range& e) {
29524       {
29525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29526       };
29527     } catch (std::exception& e) {
29528       {
29529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29530       };
29531     } catch (...) {
29532       {
29533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29534       };
29535     }
29536   }
29537   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29538   return jresult;
29539 }
29540
29541
29542 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29544   float arg2 ;
29545   float arg3 ;
29546
29547   arg1 = (Dali::Actor *)jarg1;
29548   arg2 = (float)jarg2;
29549   arg3 = (float)jarg3;
29550   {
29551     try {
29552       (arg1)->SetSize(arg2,arg3);
29553     } catch (std::out_of_range& e) {
29554       {
29555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29556       };
29557     } catch (std::exception& e) {
29558       {
29559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29560       };
29561     } catch (...) {
29562       {
29563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29564       };
29565     }
29566   }
29567 }
29568
29569
29570 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29572   float arg2 ;
29573   float arg3 ;
29574   float arg4 ;
29575
29576   arg1 = (Dali::Actor *)jarg1;
29577   arg2 = (float)jarg2;
29578   arg3 = (float)jarg3;
29579   arg4 = (float)jarg4;
29580   {
29581     try {
29582       (arg1)->SetSize(arg2,arg3,arg4);
29583     } catch (std::out_of_range& e) {
29584       {
29585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29586       };
29587     } catch (std::exception& e) {
29588       {
29589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29590       };
29591     } catch (...) {
29592       {
29593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29594       };
29595     }
29596   }
29597 }
29598
29599
29600 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29602   Dali::Vector2 *arg2 = 0 ;
29603
29604   arg1 = (Dali::Actor *)jarg1;
29605   arg2 = (Dali::Vector2 *)jarg2;
29606   if (!arg2) {
29607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29608     return ;
29609   }
29610   {
29611     try {
29612       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29613     } catch (std::out_of_range& e) {
29614       {
29615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29616       };
29617     } catch (std::exception& e) {
29618       {
29619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29620       };
29621     } catch (...) {
29622       {
29623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29624       };
29625     }
29626   }
29627 }
29628
29629
29630 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29632   Dali::Vector3 *arg2 = 0 ;
29633
29634   arg1 = (Dali::Actor *)jarg1;
29635   arg2 = (Dali::Vector3 *)jarg2;
29636   if (!arg2) {
29637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29638     return ;
29639   }
29640   {
29641     try {
29642       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29643     } catch (std::out_of_range& e) {
29644       {
29645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29646       };
29647     } catch (std::exception& e) {
29648       {
29649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29650       };
29651     } catch (...) {
29652       {
29653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29654       };
29655     }
29656   }
29657 }
29658
29659
29660 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetTargetSize(void * jarg1) {
29661   void * jresult ;
29662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29663   Dali::Vector3 result;
29664
29665   arg1 = (Dali::Actor *)jarg1;
29666   {
29667     try {
29668       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29669     } catch (std::out_of_range& e) {
29670       {
29671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29672       };
29673     } catch (std::exception& e) {
29674       {
29675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29676       };
29677     } catch (...) {
29678       {
29679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29680       };
29681     }
29682   }
29683   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentSize(void * jarg1) {
29689   void * jresult ;
29690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29691   Dali::Vector3 result;
29692
29693   arg1 = (Dali::Actor *)jarg1;
29694   {
29695     try {
29696       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29697     } catch (std::out_of_range& e) {
29698       {
29699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29700       };
29701     } catch (std::exception& e) {
29702       {
29703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (...) {
29706       {
29707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29708       };
29709     }
29710   }
29711   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29712   return jresult;
29713 }
29714
29715
29716 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetNaturalSize(void * jarg1) {
29717   void * jresult ;
29718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29719   Dali::Vector3 result;
29720
29721   arg1 = (Dali::Actor *)jarg1;
29722   {
29723     try {
29724       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29725     } catch (std::out_of_range& e) {
29726       {
29727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29728       };
29729     } catch (std::exception& e) {
29730       {
29731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29732       };
29733     } catch (...) {
29734       {
29735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29736       };
29737     }
29738   }
29739   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29740   return jresult;
29741 }
29742
29743
29744 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29746   float arg2 ;
29747   float arg3 ;
29748
29749   arg1 = (Dali::Actor *)jarg1;
29750   arg2 = (float)jarg2;
29751   arg3 = (float)jarg3;
29752   {
29753     try {
29754       (arg1)->SetPosition(arg2,arg3);
29755     } catch (std::out_of_range& e) {
29756       {
29757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29758       };
29759     } catch (std::exception& e) {
29760       {
29761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29762       };
29763     } catch (...) {
29764       {
29765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29766       };
29767     }
29768   }
29769 }
29770
29771
29772 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29774   float arg2 ;
29775   float arg3 ;
29776   float arg4 ;
29777
29778   arg1 = (Dali::Actor *)jarg1;
29779   arg2 = (float)jarg2;
29780   arg3 = (float)jarg3;
29781   arg4 = (float)jarg4;
29782   {
29783     try {
29784       (arg1)->SetPosition(arg2,arg3,arg4);
29785     } catch (std::out_of_range& e) {
29786       {
29787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29788       };
29789     } catch (std::exception& e) {
29790       {
29791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29792       };
29793     } catch (...) {
29794       {
29795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29796       };
29797     }
29798   }
29799 }
29800
29801
29802 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29804   Dali::Vector3 *arg2 = 0 ;
29805
29806   arg1 = (Dali::Actor *)jarg1;
29807   arg2 = (Dali::Vector3 *)jarg2;
29808   if (!arg2) {
29809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29810     return ;
29811   }
29812   {
29813     try {
29814       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
29815     } catch (std::out_of_range& e) {
29816       {
29817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29818       };
29819     } catch (std::exception& e) {
29820       {
29821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29822       };
29823     } catch (...) {
29824       {
29825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29826       };
29827     }
29828   }
29829 }
29830
29831
29832 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetX(void * jarg1, float jarg2) {
29833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29834   float arg2 ;
29835
29836   arg1 = (Dali::Actor *)jarg1;
29837   arg2 = (float)jarg2;
29838   {
29839     try {
29840       (arg1)->SetX(arg2);
29841     } catch (std::out_of_range& e) {
29842       {
29843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29844       };
29845     } catch (std::exception& e) {
29846       {
29847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29848       };
29849     } catch (...) {
29850       {
29851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29852       };
29853     }
29854   }
29855 }
29856
29857
29858 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetY(void * jarg1, float jarg2) {
29859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29860   float arg2 ;
29861
29862   arg1 = (Dali::Actor *)jarg1;
29863   arg2 = (float)jarg2;
29864   {
29865     try {
29866       (arg1)->SetY(arg2);
29867     } catch (std::out_of_range& e) {
29868       {
29869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29870       };
29871     } catch (std::exception& e) {
29872       {
29873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29874       };
29875     } catch (...) {
29876       {
29877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29878       };
29879     }
29880   }
29881 }
29882
29883
29884 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetZ(void * jarg1, float jarg2) {
29885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29886   float arg2 ;
29887
29888   arg1 = (Dali::Actor *)jarg1;
29889   arg2 = (float)jarg2;
29890   {
29891     try {
29892       (arg1)->SetZ(arg2);
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29900       };
29901     } catch (...) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29904       };
29905     }
29906   }
29907 }
29908
29909
29910 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_TranslateBy(void * jarg1, void * jarg2) {
29911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29912   Dali::Vector3 *arg2 = 0 ;
29913
29914   arg1 = (Dali::Actor *)jarg1;
29915   arg2 = (Dali::Vector3 *)jarg2;
29916   if (!arg2) {
29917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29918     return ;
29919   }
29920   {
29921     try {
29922       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
29923     } catch (std::out_of_range& e) {
29924       {
29925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29926       };
29927     } catch (std::exception& e) {
29928       {
29929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29930       };
29931     } catch (...) {
29932       {
29933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29934       };
29935     }
29936   }
29937 }
29938
29939
29940 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentPosition(void * jarg1) {
29941   void * jresult ;
29942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29943   Dali::Vector3 result;
29944
29945   arg1 = (Dali::Actor *)jarg1;
29946   {
29947     try {
29948       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
29949     } catch (std::out_of_range& e) {
29950       {
29951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29952       };
29953     } catch (std::exception& e) {
29954       {
29955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29956       };
29957     } catch (...) {
29958       {
29959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29960       };
29961     }
29962   }
29963   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29964   return jresult;
29965 }
29966
29967
29968 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldPosition(void * jarg1) {
29969   void * jresult ;
29970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29971   Dali::Vector3 result;
29972
29973   arg1 = (Dali::Actor *)jarg1;
29974   {
29975     try {
29976       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
29977     } catch (std::out_of_range& e) {
29978       {
29979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (std::exception& e) {
29982       {
29983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (...) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29988       };
29989     }
29990   }
29991   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29992   return jresult;
29993 }
29994
29995
29996 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
29997   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29998   bool arg2 ;
29999
30000   arg1 = (Dali::Actor *)jarg1;
30001   arg2 = jarg2 ? true : false;
30002   {
30003     try {
30004       (arg1)->SetInheritPosition(arg2);
30005     } catch (std::out_of_range& e) {
30006       {
30007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30008       };
30009     } catch (std::exception& e) {
30010       {
30011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30012       };
30013     } catch (...) {
30014       {
30015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30016       };
30017     }
30018   }
30019 }
30020
30021
30022 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetPositionInheritanceMode(void * jarg1) {
30023   int jresult ;
30024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30025   Dali::PositionInheritanceMode result;
30026
30027   arg1 = (Dali::Actor *)jarg1;
30028   {
30029     try {
30030       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (...) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30042       };
30043     }
30044   }
30045   jresult = (int)result;
30046   return jresult;
30047 }
30048
30049
30050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsPositionInherited(void * jarg1) {
30051   unsigned int jresult ;
30052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30053   bool result;
30054
30055   arg1 = (Dali::Actor *)jarg1;
30056   {
30057     try {
30058       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30059     } catch (std::out_of_range& e) {
30060       {
30061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30062       };
30063     } catch (std::exception& e) {
30064       {
30065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30066       };
30067     } catch (...) {
30068       {
30069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30070       };
30071     }
30072   }
30073   jresult = result;
30074   return jresult;
30075 }
30076
30077
30078 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30080   Dali::Degree *arg2 = 0 ;
30081   Dali::Vector3 *arg3 = 0 ;
30082
30083   arg1 = (Dali::Actor *)jarg1;
30084   arg2 = (Dali::Degree *)jarg2;
30085   if (!arg2) {
30086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30087     return ;
30088   }
30089   arg3 = (Dali::Vector3 *)jarg3;
30090   if (!arg3) {
30091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30092     return ;
30093   }
30094   {
30095     try {
30096       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30097     } catch (std::out_of_range& e) {
30098       {
30099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30100       };
30101     } catch (std::exception& e) {
30102       {
30103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30104       };
30105     } catch (...) {
30106       {
30107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30108       };
30109     }
30110   }
30111 }
30112
30113
30114 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30116   Dali::Radian *arg2 = 0 ;
30117   Dali::Vector3 *arg3 = 0 ;
30118
30119   arg1 = (Dali::Actor *)jarg1;
30120   arg2 = (Dali::Radian *)jarg2;
30121   if (!arg2) {
30122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30123     return ;
30124   }
30125   arg3 = (Dali::Vector3 *)jarg3;
30126   if (!arg3) {
30127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30128     return ;
30129   }
30130   {
30131     try {
30132       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30133     } catch (std::out_of_range& e) {
30134       {
30135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30136       };
30137     } catch (std::exception& e) {
30138       {
30139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30140       };
30141     } catch (...) {
30142       {
30143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30144       };
30145     }
30146   }
30147 }
30148
30149
30150 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30152   Dali::Quaternion *arg2 = 0 ;
30153
30154   arg1 = (Dali::Actor *)jarg1;
30155   arg2 = (Dali::Quaternion *)jarg2;
30156   if (!arg2) {
30157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30158     return ;
30159   }
30160   {
30161     try {
30162       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30163     } catch (std::out_of_range& e) {
30164       {
30165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30166       };
30167     } catch (std::exception& e) {
30168       {
30169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30170       };
30171     } catch (...) {
30172       {
30173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30174       };
30175     }
30176   }
30177 }
30178
30179
30180 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30182   Dali::Degree *arg2 = 0 ;
30183   Dali::Vector3 *arg3 = 0 ;
30184
30185   arg1 = (Dali::Actor *)jarg1;
30186   arg2 = (Dali::Degree *)jarg2;
30187   if (!arg2) {
30188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30189     return ;
30190   }
30191   arg3 = (Dali::Vector3 *)jarg3;
30192   if (!arg3) {
30193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30194     return ;
30195   }
30196   {
30197     try {
30198       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30199     } catch (std::out_of_range& e) {
30200       {
30201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30202       };
30203     } catch (std::exception& e) {
30204       {
30205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30206       };
30207     } catch (...) {
30208       {
30209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30210       };
30211     }
30212   }
30213 }
30214
30215
30216 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30218   Dali::Radian *arg2 = 0 ;
30219   Dali::Vector3 *arg3 = 0 ;
30220
30221   arg1 = (Dali::Actor *)jarg1;
30222   arg2 = (Dali::Radian *)jarg2;
30223   if (!arg2) {
30224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30225     return ;
30226   }
30227   arg3 = (Dali::Vector3 *)jarg3;
30228   if (!arg3) {
30229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30230     return ;
30231   }
30232   {
30233     try {
30234       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30235     } catch (std::out_of_range& e) {
30236       {
30237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30238       };
30239     } catch (std::exception& e) {
30240       {
30241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30242       };
30243     } catch (...) {
30244       {
30245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30246       };
30247     }
30248   }
30249 }
30250
30251
30252 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30254   Dali::Quaternion *arg2 = 0 ;
30255
30256   arg1 = (Dali::Actor *)jarg1;
30257   arg2 = (Dali::Quaternion *)jarg2;
30258   if (!arg2) {
30259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30260     return ;
30261   }
30262   {
30263     try {
30264       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30265     } catch (std::out_of_range& e) {
30266       {
30267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30268       };
30269     } catch (std::exception& e) {
30270       {
30271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30276       };
30277     }
30278   }
30279 }
30280
30281
30282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentOrientation(void * jarg1) {
30283   void * jresult ;
30284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30285   Dali::Quaternion result;
30286
30287   arg1 = (Dali::Actor *)jarg1;
30288   {
30289     try {
30290       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30291     } catch (std::out_of_range& e) {
30292       {
30293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30294       };
30295     } catch (std::exception& e) {
30296       {
30297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (...) {
30300       {
30301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30302       };
30303     }
30304   }
30305   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30306   return jresult;
30307 }
30308
30309
30310 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30312   bool arg2 ;
30313
30314   arg1 = (Dali::Actor *)jarg1;
30315   arg2 = jarg2 ? true : false;
30316   {
30317     try {
30318       (arg1)->SetInheritOrientation(arg2);
30319     } catch (std::out_of_range& e) {
30320       {
30321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30322       };
30323     } catch (std::exception& e) {
30324       {
30325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (...) {
30328       {
30329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30330       };
30331     }
30332   }
30333 }
30334
30335
30336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsOrientationInherited(void * jarg1) {
30337   unsigned int jresult ;
30338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30339   bool result;
30340
30341   arg1 = (Dali::Actor *)jarg1;
30342   {
30343     try {
30344       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30345     } catch (std::out_of_range& e) {
30346       {
30347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30348       };
30349     } catch (std::exception& e) {
30350       {
30351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (...) {
30354       {
30355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30356       };
30357     }
30358   }
30359   jresult = result;
30360   return jresult;
30361 }
30362
30363
30364 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldOrientation(void * jarg1) {
30365   void * jresult ;
30366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30367   Dali::Quaternion result;
30368
30369   arg1 = (Dali::Actor *)jarg1;
30370   {
30371     try {
30372       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30373     } catch (std::out_of_range& e) {
30374       {
30375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30376       };
30377     } catch (std::exception& e) {
30378       {
30379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30380       };
30381     } catch (...) {
30382       {
30383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30384       };
30385     }
30386   }
30387   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30388   return jresult;
30389 }
30390
30391
30392 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30393   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30394   float arg2 ;
30395
30396   arg1 = (Dali::Actor *)jarg1;
30397   arg2 = (float)jarg2;
30398   {
30399     try {
30400       (arg1)->SetScale(arg2);
30401     } catch (std::out_of_range& e) {
30402       {
30403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30404       };
30405     } catch (std::exception& e) {
30406       {
30407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30408       };
30409     } catch (...) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30412       };
30413     }
30414   }
30415 }
30416
30417
30418 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30419   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30420   float arg2 ;
30421   float arg3 ;
30422   float arg4 ;
30423
30424   arg1 = (Dali::Actor *)jarg1;
30425   arg2 = (float)jarg2;
30426   arg3 = (float)jarg3;
30427   arg4 = (float)jarg4;
30428   {
30429     try {
30430       (arg1)->SetScale(arg2,arg3,arg4);
30431     } catch (std::out_of_range& e) {
30432       {
30433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30434       };
30435     } catch (std::exception& e) {
30436       {
30437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (...) {
30440       {
30441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30442       };
30443     }
30444   }
30445 }
30446
30447
30448 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30450   Dali::Vector3 *arg2 = 0 ;
30451
30452   arg1 = (Dali::Actor *)jarg1;
30453   arg2 = (Dali::Vector3 *)jarg2;
30454   if (!arg2) {
30455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30456     return ;
30457   }
30458   {
30459     try {
30460       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (...) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30472       };
30473     }
30474   }
30475 }
30476
30477
30478 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_ScaleBy(void * jarg1, void * jarg2) {
30479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30480   Dali::Vector3 *arg2 = 0 ;
30481
30482   arg1 = (Dali::Actor *)jarg1;
30483   arg2 = (Dali::Vector3 *)jarg2;
30484   if (!arg2) {
30485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30486     return ;
30487   }
30488   {
30489     try {
30490       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30491     } catch (std::out_of_range& e) {
30492       {
30493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30494       };
30495     } catch (std::exception& e) {
30496       {
30497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30498       };
30499     } catch (...) {
30500       {
30501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30502       };
30503     }
30504   }
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentScale(void * jarg1) {
30509   void * jresult ;
30510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30511   Dali::Vector3 result;
30512
30513   arg1 = (Dali::Actor *)jarg1;
30514   {
30515     try {
30516       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30517     } catch (std::out_of_range& e) {
30518       {
30519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30520       };
30521     } catch (std::exception& e) {
30522       {
30523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30524       };
30525     } catch (...) {
30526       {
30527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30528       };
30529     }
30530   }
30531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldScale(void * jarg1) {
30537   void * jresult ;
30538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30539   Dali::Vector3 result;
30540
30541   arg1 = (Dali::Actor *)jarg1;
30542   {
30543     try {
30544       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30545     } catch (std::out_of_range& e) {
30546       {
30547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30548       };
30549     } catch (std::exception& e) {
30550       {
30551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30552       };
30553     } catch (...) {
30554       {
30555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30556       };
30557     }
30558   }
30559   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30560   return jresult;
30561 }
30562
30563
30564 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30566   bool arg2 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = jarg2 ? true : false;
30570   {
30571     try {
30572       (arg1)->SetInheritScale(arg2);
30573     } catch (std::out_of_range& e) {
30574       {
30575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30576       };
30577     } catch (std::exception& e) {
30578       {
30579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30584       };
30585     }
30586   }
30587 }
30588
30589
30590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsScaleInherited(void * jarg1) {
30591   unsigned int jresult ;
30592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30593   bool result;
30594
30595   arg1 = (Dali::Actor *)jarg1;
30596   {
30597     try {
30598       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30610       };
30611     }
30612   }
30613   jresult = result;
30614   return jresult;
30615 }
30616
30617
30618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldMatrix(void * jarg1) {
30619   void * jresult ;
30620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30621   Dali::Matrix result;
30622
30623   arg1 = (Dali::Actor *)jarg1;
30624   {
30625     try {
30626       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30627     } catch (std::out_of_range& e) {
30628       {
30629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30630       };
30631     } catch (std::exception& e) {
30632       {
30633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30634       };
30635     } catch (...) {
30636       {
30637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30638       };
30639     }
30640   }
30641   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30648   bool arg2 ;
30649
30650   arg1 = (Dali::Actor *)jarg1;
30651   arg2 = jarg2 ? true : false;
30652   {
30653     try {
30654       (arg1)->SetVisible(arg2);
30655     } catch (std::out_of_range& e) {
30656       {
30657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30658       };
30659     } catch (std::exception& e) {
30660       {
30661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30662       };
30663     } catch (...) {
30664       {
30665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30666       };
30667     }
30668   }
30669 }
30670
30671
30672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsVisible(void * jarg1) {
30673   unsigned int jresult ;
30674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30675   bool result;
30676
30677   arg1 = (Dali::Actor *)jarg1;
30678   {
30679     try {
30680       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30681     } catch (std::out_of_range& e) {
30682       {
30683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30684       };
30685     } catch (std::exception& e) {
30686       {
30687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30688       };
30689     } catch (...) {
30690       {
30691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30692       };
30693     }
30694   }
30695   jresult = result;
30696   return jresult;
30697 }
30698
30699
30700 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetOpacity(void * jarg1, float jarg2) {
30701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30702   float arg2 ;
30703
30704   arg1 = (Dali::Actor *)jarg1;
30705   arg2 = (float)jarg2;
30706   {
30707     try {
30708       (arg1)->SetOpacity(arg2);
30709     } catch (std::out_of_range& e) {
30710       {
30711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30712       };
30713     } catch (std::exception& e) {
30714       {
30715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30716       };
30717     } catch (...) {
30718       {
30719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30720       };
30721     }
30722   }
30723 }
30724
30725
30726 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetCurrentOpacity(void * jarg1) {
30727   float jresult ;
30728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30729   float result;
30730
30731   arg1 = (Dali::Actor *)jarg1;
30732   {
30733     try {
30734       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30735     } catch (std::out_of_range& e) {
30736       {
30737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30738       };
30739     } catch (std::exception& e) {
30740       {
30741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30742       };
30743     } catch (...) {
30744       {
30745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30746       };
30747     }
30748   }
30749   jresult = result;
30750   return jresult;
30751 }
30752
30753
30754 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetColor(void * jarg1, void * jarg2) {
30755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30756   Dali::Vector4 *arg2 = 0 ;
30757
30758   arg1 = (Dali::Actor *)jarg1;
30759   arg2 = (Dali::Vector4 *)jarg2;
30760   if (!arg2) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30762     return ;
30763   }
30764   {
30765     try {
30766       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30774       };
30775     } catch (...) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30778       };
30779     }
30780   }
30781 }
30782
30783
30784 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentColor(void * jarg1) {
30785   void * jresult ;
30786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30787   Dali::Vector4 result;
30788
30789   arg1 = (Dali::Actor *)jarg1;
30790   {
30791     try {
30792       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30793     } catch (std::out_of_range& e) {
30794       {
30795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30796       };
30797     } catch (std::exception& e) {
30798       {
30799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30800       };
30801     } catch (...) {
30802       {
30803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30804       };
30805     }
30806   }
30807   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30808   return jresult;
30809 }
30810
30811
30812 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetColorMode(void * jarg1, int jarg2) {
30813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30814   Dali::ColorMode arg2 ;
30815
30816   arg1 = (Dali::Actor *)jarg1;
30817   arg2 = (Dali::ColorMode)jarg2;
30818   {
30819     try {
30820       (arg1)->SetColorMode(arg2);
30821     } catch (std::out_of_range& e) {
30822       {
30823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30824       };
30825     } catch (std::exception& e) {
30826       {
30827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30828       };
30829     } catch (...) {
30830       {
30831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30832       };
30833     }
30834   }
30835 }
30836
30837
30838 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetColorMode(void * jarg1) {
30839   int jresult ;
30840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30841   Dali::ColorMode result;
30842
30843   arg1 = (Dali::Actor *)jarg1;
30844   {
30845     try {
30846       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
30847     } catch (std::out_of_range& e) {
30848       {
30849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30850       };
30851     } catch (std::exception& e) {
30852       {
30853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30854       };
30855     } catch (...) {
30856       {
30857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30858       };
30859     }
30860   }
30861   jresult = (int)result;
30862   return jresult;
30863 }
30864
30865
30866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetCurrentWorldColor(void * jarg1) {
30867   void * jresult ;
30868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30869   Dali::Vector4 result;
30870
30871   arg1 = (Dali::Actor *)jarg1;
30872   {
30873     try {
30874       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
30875     } catch (std::out_of_range& e) {
30876       {
30877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30878       };
30879     } catch (std::exception& e) {
30880       {
30881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30882       };
30883     } catch (...) {
30884       {
30885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30886       };
30887     }
30888   }
30889   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30890   return jresult;
30891 }
30892
30893
30894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetDrawMode(void * jarg1, int jarg2) {
30895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30896   Dali::DrawMode::Type arg2 ;
30897
30898   arg1 = (Dali::Actor *)jarg1;
30899   arg2 = (Dali::DrawMode::Type)jarg2;
30900   {
30901     try {
30902       (arg1)->SetDrawMode(arg2);
30903     } catch (std::out_of_range& e) {
30904       {
30905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30906       };
30907     } catch (std::exception& e) {
30908       {
30909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30910       };
30911     } catch (...) {
30912       {
30913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30914       };
30915     }
30916   }
30917 }
30918
30919
30920 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetDrawMode(void * jarg1) {
30921   int jresult ;
30922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30923   Dali::DrawMode::Type result;
30924
30925   arg1 = (Dali::Actor *)jarg1;
30926   {
30927     try {
30928       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30936       };
30937     } catch (...) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30940       };
30941     }
30942   }
30943   jresult = (int)result;
30944   return jresult;
30945 }
30946
30947
30948 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
30949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30950   bool arg2 ;
30951
30952   arg1 = (Dali::Actor *)jarg1;
30953   arg2 = jarg2 ? true : false;
30954   {
30955     try {
30956       (arg1)->SetSensitive(arg2);
30957     } catch (std::out_of_range& e) {
30958       {
30959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30960       };
30961     } catch (std::exception& e) {
30962       {
30963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30964       };
30965     } catch (...) {
30966       {
30967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30968       };
30969     }
30970   }
30971 }
30972
30973
30974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsSensitive(void * jarg1) {
30975   unsigned int jresult ;
30976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30977   bool result;
30978
30979   arg1 = (Dali::Actor *)jarg1;
30980   {
30981     try {
30982       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
30983     } catch (std::out_of_range& e) {
30984       {
30985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30986       };
30987     } catch (std::exception& e) {
30988       {
30989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30990       };
30991     } catch (...) {
30992       {
30993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30994       };
30995     }
30996   }
30997   jresult = result;
30998   return jresult;
30999 }
31000
31001
31002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31003   unsigned int jresult ;
31004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31005   float *arg2 = 0 ;
31006   float *arg3 = 0 ;
31007   float arg4 ;
31008   float arg5 ;
31009   bool result;
31010
31011   arg1 = (Dali::Actor *)jarg1;
31012   arg2 = (float *)jarg2;
31013   arg3 = (float *)jarg3;
31014   arg4 = (float)jarg4;
31015   arg5 = (float)jarg5;
31016   {
31017     try {
31018       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31019     } catch (std::out_of_range& e) {
31020       {
31021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31022       };
31023     } catch (std::exception& e) {
31024       {
31025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31026       };
31027     } catch (...) {
31028       {
31029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31030       };
31031     }
31032   }
31033   jresult = result;
31034   return jresult;
31035 }
31036
31037
31038 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31040   bool arg2 ;
31041
31042   arg1 = (Dali::Actor *)jarg1;
31043   arg2 = jarg2 ? true : false;
31044   {
31045     try {
31046       (arg1)->SetLeaveRequired(arg2);
31047     } catch (std::out_of_range& e) {
31048       {
31049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31050       };
31051     } catch (std::exception& e) {
31052       {
31053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31054       };
31055     } catch (...) {
31056       {
31057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31058       };
31059     }
31060   }
31061 }
31062
31063
31064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetLeaveRequired(void * jarg1) {
31065   unsigned int jresult ;
31066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31067   bool result;
31068
31069   arg1 = (Dali::Actor *)jarg1;
31070   {
31071     try {
31072       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (...) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31084       };
31085     }
31086   }
31087   jresult = result;
31088   return jresult;
31089 }
31090
31091
31092 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31094   bool arg2 ;
31095
31096   arg1 = (Dali::Actor *)jarg1;
31097   arg2 = jarg2 ? true : false;
31098   {
31099     try {
31100       (arg1)->SetKeyboardFocusable(arg2);
31101     } catch (std::out_of_range& e) {
31102       {
31103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31104       };
31105     } catch (std::exception& e) {
31106       {
31107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31108       };
31109     } catch (...) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31112       };
31113     }
31114   }
31115 }
31116
31117
31118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_IsKeyboardFocusable(void * jarg1) {
31119   unsigned int jresult ;
31120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31121   bool result;
31122
31123   arg1 = (Dali::Actor *)jarg1;
31124   {
31125     try {
31126       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31127     } catch (std::out_of_range& e) {
31128       {
31129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31130       };
31131     } catch (std::exception& e) {
31132       {
31133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31134       };
31135     } catch (...) {
31136       {
31137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31138       };
31139     }
31140   }
31141   jresult = result;
31142   return jresult;
31143 }
31144
31145
31146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31148   Dali::ResizePolicy::Type arg2 ;
31149   Dali::Dimension::Type arg3 ;
31150
31151   arg1 = (Dali::Actor *)jarg1;
31152   arg2 = (Dali::ResizePolicy::Type)jarg2;
31153   arg3 = (Dali::Dimension::Type)jarg3;
31154   {
31155     try {
31156       (arg1)->SetResizePolicy(arg2,arg3);
31157     } catch (std::out_of_range& e) {
31158       {
31159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31160       };
31161     } catch (std::exception& e) {
31162       {
31163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31164       };
31165     } catch (...) {
31166       {
31167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31168       };
31169     }
31170   }
31171 }
31172
31173
31174 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31175   int jresult ;
31176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31177   Dali::Dimension::Type arg2 ;
31178   Dali::ResizePolicy::Type result;
31179
31180   arg1 = (Dali::Actor *)jarg1;
31181   arg2 = (Dali::Dimension::Type)jarg2;
31182   {
31183     try {
31184       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31185     } catch (std::out_of_range& e) {
31186       {
31187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31188       };
31189     } catch (std::exception& e) {
31190       {
31191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31192       };
31193     } catch (...) {
31194       {
31195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31196       };
31197     }
31198   }
31199   jresult = (int)result;
31200   return jresult;
31201 }
31202
31203
31204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31206   Dali::SizeScalePolicy::Type arg2 ;
31207
31208   arg1 = (Dali::Actor *)jarg1;
31209   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31210   {
31211     try {
31212       (arg1)->SetSizeScalePolicy(arg2);
31213     } catch (std::out_of_range& e) {
31214       {
31215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31216       };
31217     } catch (std::exception& e) {
31218       {
31219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31220       };
31221     } catch (...) {
31222       {
31223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31224       };
31225     }
31226   }
31227 }
31228
31229
31230 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetSizeScalePolicy(void * jarg1) {
31231   int jresult ;
31232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31233   Dali::SizeScalePolicy::Type result;
31234
31235   arg1 = (Dali::Actor *)jarg1;
31236   {
31237     try {
31238       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31250       };
31251     }
31252   }
31253   jresult = (int)result;
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31260   Dali::Vector3 *arg2 = 0 ;
31261
31262   arg1 = (Dali::Actor *)jarg1;
31263   arg2 = (Dali::Vector3 *)jarg2;
31264   if (!arg2) {
31265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31266     return ;
31267   }
31268   {
31269     try {
31270       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31271     } catch (std::out_of_range& e) {
31272       {
31273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31274       };
31275     } catch (std::exception& e) {
31276       {
31277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31278       };
31279     } catch (...) {
31280       {
31281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31282       };
31283     }
31284   }
31285 }
31286
31287
31288 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetSizeModeFactor(void * jarg1) {
31289   void * jresult ;
31290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31291   Dali::Vector3 result;
31292
31293   arg1 = (Dali::Actor *)jarg1;
31294   {
31295     try {
31296       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31297     } catch (std::out_of_range& e) {
31298       {
31299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (std::exception& e) {
31302       {
31303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (...) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31308       };
31309     }
31310   }
31311   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31312   return jresult;
31313 }
31314
31315
31316 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31317   float jresult ;
31318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31319   float arg2 ;
31320   float result;
31321
31322   arg1 = (Dali::Actor *)jarg1;
31323   arg2 = (float)jarg2;
31324   {
31325     try {
31326       result = (float)(arg1)->GetHeightForWidth(arg2);
31327     } catch (std::out_of_range& e) {
31328       {
31329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31330       };
31331     } catch (std::exception& e) {
31332       {
31333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31334       };
31335     } catch (...) {
31336       {
31337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31338       };
31339     }
31340   }
31341   jresult = result;
31342   return jresult;
31343 }
31344
31345
31346 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31347   float jresult ;
31348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31349   float arg2 ;
31350   float result;
31351
31352   arg1 = (Dali::Actor *)jarg1;
31353   arg2 = (float)jarg2;
31354   {
31355     try {
31356       result = (float)(arg1)->GetWidthForHeight(arg2);
31357     } catch (std::out_of_range& e) {
31358       {
31359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31360       };
31361     } catch (std::exception& e) {
31362       {
31363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31364       };
31365     } catch (...) {
31366       {
31367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31368       };
31369     }
31370   }
31371   jresult = result;
31372   return jresult;
31373 }
31374
31375
31376 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31377   float jresult ;
31378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31379   Dali::Dimension::Type arg2 ;
31380   float result;
31381
31382   arg1 = (Dali::Actor *)jarg1;
31383   arg2 = (Dali::Dimension::Type)jarg2;
31384   {
31385     try {
31386       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31398       };
31399     }
31400   }
31401   jresult = result;
31402   return jresult;
31403 }
31404
31405
31406 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetPadding(void * jarg1, void * jarg2) {
31407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31408   Dali::Padding *arg2 = 0 ;
31409
31410   arg1 = (Dali::Actor *)jarg1;
31411   arg2 = (Dali::Padding *)jarg2;
31412   if (!arg2) {
31413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31414     return ;
31415   }
31416   {
31417     try {
31418       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31419     } catch (std::out_of_range& e) {
31420       {
31421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31422       };
31423     } catch (std::exception& e) {
31424       {
31425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31426       };
31427     } catch (...) {
31428       {
31429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31430       };
31431     }
31432   }
31433 }
31434
31435
31436 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_GetPadding(void * jarg1, void * jarg2) {
31437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31438   Dali::Padding *arg2 = 0 ;
31439
31440   arg1 = (Dali::Actor *)jarg1;
31441   arg2 = (Dali::Padding *)jarg2;
31442   if (!arg2) {
31443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31444     return ;
31445   }
31446   {
31447     try {
31448       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31449     } catch (std::out_of_range& e) {
31450       {
31451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31452       };
31453     } catch (std::exception& e) {
31454       {
31455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31456       };
31457     } catch (...) {
31458       {
31459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31460       };
31461     }
31462   }
31463 }
31464
31465
31466 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31468   Dali::Vector2 *arg2 = 0 ;
31469
31470   arg1 = (Dali::Actor *)jarg1;
31471   arg2 = (Dali::Vector2 *)jarg2;
31472   if (!arg2) {
31473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31474     return ;
31475   }
31476   {
31477     try {
31478       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31479     } catch (std::out_of_range& e) {
31480       {
31481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31482       };
31483     } catch (std::exception& e) {
31484       {
31485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31486       };
31487     } catch (...) {
31488       {
31489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31490       };
31491     }
31492   }
31493 }
31494
31495
31496 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetMinimumSize(void * jarg1) {
31497   void * jresult ;
31498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31499   Dali::Vector2 result;
31500
31501   arg1 = (Dali::Actor *)jarg1;
31502   {
31503     try {
31504       result = (arg1)->GetMinimumSize();
31505     } catch (std::out_of_range& e) {
31506       {
31507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31508       };
31509     } catch (std::exception& e) {
31510       {
31511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31512       };
31513     } catch (...) {
31514       {
31515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31516       };
31517     }
31518   }
31519   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31520   return jresult;
31521 }
31522
31523
31524 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31526   Dali::Vector2 *arg2 = 0 ;
31527
31528   arg1 = (Dali::Actor *)jarg1;
31529   arg2 = (Dali::Vector2 *)jarg2;
31530   if (!arg2) {
31531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31532     return ;
31533   }
31534   {
31535     try {
31536       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31537     } catch (std::out_of_range& e) {
31538       {
31539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31540       };
31541     } catch (std::exception& e) {
31542       {
31543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31544       };
31545     } catch (...) {
31546       {
31547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31548       };
31549     }
31550   }
31551 }
31552
31553
31554 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetMaximumSize(void * jarg1) {
31555   void * jresult ;
31556   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31557   Dali::Vector2 result;
31558
31559   arg1 = (Dali::Actor *)jarg1;
31560   {
31561     try {
31562       result = (arg1)->GetMaximumSize();
31563     } catch (std::out_of_range& e) {
31564       {
31565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31566       };
31567     } catch (std::exception& e) {
31568       {
31569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31570       };
31571     } catch (...) {
31572       {
31573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31574       };
31575     }
31576   }
31577   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31578   return jresult;
31579 }
31580
31581
31582 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Actor_GetHierarchyDepth(void * jarg1) {
31583   int jresult ;
31584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31585   int result;
31586
31587   arg1 = (Dali::Actor *)jarg1;
31588   {
31589     try {
31590       result = (int)(arg1)->GetHierarchyDepth();
31591     } catch (std::out_of_range& e) {
31592       {
31593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31594       };
31595     } catch (std::exception& e) {
31596       {
31597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31598       };
31599     } catch (...) {
31600       {
31601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31602       };
31603     }
31604   }
31605   jresult = result;
31606   return jresult;
31607 }
31608
31609
31610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_AddRenderer(void * jarg1, void * jarg2) {
31611   unsigned int jresult ;
31612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31613   Dali::Renderer *arg2 = 0 ;
31614   unsigned int result;
31615
31616   arg1 = (Dali::Actor *)jarg1;
31617   arg2 = (Dali::Renderer *)jarg2;
31618   if (!arg2) {
31619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31620     return 0;
31621   }
31622   {
31623     try {
31624       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (...) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31636       };
31637     }
31638   }
31639   jresult = result;
31640   return jresult;
31641 }
31642
31643
31644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Actor_GetRendererCount(void * jarg1) {
31645   unsigned int jresult ;
31646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31647   unsigned int result;
31648
31649   arg1 = (Dali::Actor *)jarg1;
31650   {
31651     try {
31652       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31653     } catch (std::out_of_range& e) {
31654       {
31655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (std::exception& e) {
31658       {
31659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31664       };
31665     }
31666   }
31667   jresult = result;
31668   return jresult;
31669 }
31670
31671
31672 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31673   void * jresult ;
31674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31675   unsigned int arg2 ;
31676   Dali::Renderer result;
31677
31678   arg1 = (Dali::Actor *)jarg1;
31679   arg2 = (unsigned int)jarg2;
31680   {
31681     try {
31682       result = (arg1)->GetRendererAt(arg2);
31683     } catch (std::out_of_range& e) {
31684       {
31685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31686       };
31687     } catch (std::exception& e) {
31688       {
31689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31690       };
31691     } catch (...) {
31692       {
31693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31694       };
31695     }
31696   }
31697   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31698   return jresult;
31699 }
31700
31701
31702 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31704   Dali::Renderer *arg2 = 0 ;
31705
31706   arg1 = (Dali::Actor *)jarg1;
31707   arg2 = (Dali::Renderer *)jarg2;
31708   if (!arg2) {
31709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31710     return ;
31711   }
31712   {
31713     try {
31714       (arg1)->RemoveRenderer(*arg2);
31715     } catch (std::out_of_range& e) {
31716       {
31717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31718       };
31719     } catch (std::exception& e) {
31720       {
31721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31722       };
31723     } catch (...) {
31724       {
31725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31726       };
31727     }
31728   }
31729 }
31730
31731
31732 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31734   unsigned int arg2 ;
31735
31736   arg1 = (Dali::Actor *)jarg1;
31737   arg2 = (unsigned int)jarg2;
31738   {
31739     try {
31740       (arg1)->RemoveRenderer(arg2);
31741     } catch (std::out_of_range& e) {
31742       {
31743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (std::exception& e) {
31746       {
31747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31748       };
31749     } catch (...) {
31750       {
31751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31752       };
31753     }
31754   }
31755 }
31756
31757
31758 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_TouchedSignal(void * jarg1) {
31759   void * jresult ;
31760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31761   Dali::Actor::TouchSignalType *result = 0 ;
31762
31763   arg1 = (Dali::Actor *)jarg1;
31764   {
31765     try {
31766       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31767     } catch (std::out_of_range& e) {
31768       {
31769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (std::exception& e) {
31772       {
31773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31778       };
31779     }
31780   }
31781   jresult = (void *)result;
31782   return jresult;
31783 }
31784
31785
31786 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_TouchSignal(void * jarg1) {
31787   void * jresult ;
31788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31789   Dali::Actor::TouchDataSignalType *result = 0 ;
31790
31791   arg1 = (Dali::Actor *)jarg1;
31792   {
31793     try {
31794       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31795     } catch (std::out_of_range& e) {
31796       {
31797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31798       };
31799     } catch (std::exception& e) {
31800       {
31801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (...) {
31804       {
31805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31806       };
31807     }
31808   }
31809   jresult = (void *)result;
31810   return jresult;
31811 }
31812
31813
31814 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_HoveredSignal(void * jarg1) {
31815   void * jresult ;
31816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31817   Dali::Actor::HoverSignalType *result = 0 ;
31818
31819   arg1 = (Dali::Actor *)jarg1;
31820   {
31821     try {
31822       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
31823     } catch (std::out_of_range& e) {
31824       {
31825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31826       };
31827     } catch (std::exception& e) {
31828       {
31829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (...) {
31832       {
31833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31834       };
31835     }
31836   }
31837   jresult = (void *)result;
31838   return jresult;
31839 }
31840
31841
31842 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_WheelEventSignal(void * jarg1) {
31843   void * jresult ;
31844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31845   Dali::Actor::WheelEventSignalType *result = 0 ;
31846
31847   arg1 = (Dali::Actor *)jarg1;
31848   {
31849     try {
31850       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
31851     } catch (std::out_of_range& e) {
31852       {
31853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31854       };
31855     } catch (std::exception& e) {
31856       {
31857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31858       };
31859     } catch (...) {
31860       {
31861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31862       };
31863     }
31864   }
31865   jresult = (void *)result;
31866   return jresult;
31867 }
31868
31869
31870 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OnStageSignal(void * jarg1) {
31871   void * jresult ;
31872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31873   Dali::Actor::OnStageSignalType *result = 0 ;
31874
31875   arg1 = (Dali::Actor *)jarg1;
31876   {
31877     try {
31878       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
31879     } catch (std::out_of_range& e) {
31880       {
31881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31882       };
31883     } catch (std::exception& e) {
31884       {
31885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31886       };
31887     } catch (...) {
31888       {
31889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31890       };
31891     }
31892   }
31893   jresult = (void *)result;
31894   return jresult;
31895 }
31896
31897
31898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OffStageSignal(void * jarg1) {
31899   void * jresult ;
31900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31901   Dali::Actor::OffStageSignalType *result = 0 ;
31902
31903   arg1 = (Dali::Actor *)jarg1;
31904   {
31905     try {
31906       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
31907     } catch (std::out_of_range& e) {
31908       {
31909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31910       };
31911     } catch (std::exception& e) {
31912       {
31913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31914       };
31915     } catch (...) {
31916       {
31917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31918       };
31919     }
31920   }
31921   jresult = (void *)result;
31922   return jresult;
31923 }
31924
31925
31926 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Actor_OnRelayoutSignal(void * jarg1) {
31927   void * jresult ;
31928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31929   Dali::Actor::OnRelayoutSignalType *result = 0 ;
31930
31931   arg1 = (Dali::Actor *)jarg1;
31932   {
31933     try {
31934       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
31935     } catch (std::out_of_range& e) {
31936       {
31937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31938       };
31939     } catch (std::exception& e) {
31940       {
31941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (...) {
31944       {
31945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31946       };
31947     }
31948   }
31949   jresult = (void *)result;
31950   return jresult;
31951 }
31952
31953
31954 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_UnparentAndReset(void * jarg1) {
31955   Dali::Actor *arg1 = 0 ;
31956
31957   arg1 = (Dali::Actor *)jarg1;
31958   if (!arg1) {
31959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
31960     return ;
31961   }
31962   {
31963     try {
31964       Dali::UnparentAndReset(*arg1);
31965     } catch (std::out_of_range& e) {
31966       {
31967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31968       };
31969     } catch (std::exception& e) {
31970       {
31971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31972       };
31973     } catch (...) {
31974       {
31975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31976       };
31977     }
31978   }
31979 }
31980
31981
31982 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_CLIPPING_ENABLE_get() {
31983   int jresult ;
31984   int result;
31985
31986   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
31987   jresult = (int)result;
31988   return jresult;
31989 }
31990
31991
31992 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_CLIPPING_BOX_get() {
31993   int jresult ;
31994   int result;
31995
31996   result = (int)Dali::Layer::Property::CLIPPING_BOX;
31997   jresult = (int)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_Property_BEHAVIOR_get() {
32003   int jresult ;
32004   int result;
32005
32006   result = (int)Dali::Layer::Property::BEHAVIOR;
32007   jresult = (int)result;
32008   return jresult;
32009 }
32010
32011
32012 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer_Property() {
32013   void * jresult ;
32014   Dali::Layer::Property *result = 0 ;
32015
32016   {
32017     try {
32018       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32019     } catch (std::out_of_range& e) {
32020       {
32021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32022       };
32023     } catch (std::exception& e) {
32024       {
32025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32026       };
32027     } catch (...) {
32028       {
32029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32030       };
32031     }
32032   }
32033   jresult = (void *)result;
32034   return jresult;
32035 }
32036
32037
32038 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Layer_Property(void * jarg1) {
32039   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32040
32041   arg1 = (Dali::Layer::Property *)jarg1;
32042   {
32043     try {
32044       delete arg1;
32045     } catch (std::out_of_range& e) {
32046       {
32047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32048       };
32049     } catch (std::exception& e) {
32050       {
32051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32052       };
32053     } catch (...) {
32054       {
32055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32056       };
32057     }
32058   }
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer__SWIG_0() {
32063   void * jresult ;
32064   Dali::Layer *result = 0 ;
32065
32066   {
32067     try {
32068       result = (Dali::Layer *)new Dali::Layer();
32069     } catch (std::out_of_range& e) {
32070       {
32071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32072       };
32073     } catch (std::exception& e) {
32074       {
32075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32076       };
32077     } catch (...) {
32078       {
32079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32080       };
32081     }
32082   }
32083   jresult = (void *)result;
32084   return jresult;
32085 }
32086
32087
32088 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_New() {
32089   void * jresult ;
32090   Dali::Layer result;
32091
32092   {
32093     try {
32094       result = Dali::Layer::New();
32095     } catch (std::out_of_range& e) {
32096       {
32097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32098       };
32099     } catch (std::exception& e) {
32100       {
32101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32102       };
32103     } catch (...) {
32104       {
32105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32106       };
32107     }
32108   }
32109   jresult = new Dali::Layer((const Dali::Layer &)result);
32110   return jresult;
32111 }
32112
32113
32114 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_DownCast(void * jarg1) {
32115   void * jresult ;
32116   Dali::BaseHandle arg1 ;
32117   Dali::BaseHandle *argp1 ;
32118   Dali::Layer result;
32119
32120   argp1 = (Dali::BaseHandle *)jarg1;
32121   if (!argp1) {
32122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32123     return 0;
32124   }
32125   arg1 = *argp1;
32126   {
32127     try {
32128       result = Dali::Layer::DownCast(arg1);
32129     } catch (std::out_of_range& e) {
32130       {
32131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32132       };
32133     } catch (std::exception& e) {
32134       {
32135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32136       };
32137     } catch (...) {
32138       {
32139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32140       };
32141     }
32142   }
32143   jresult = new Dali::Layer((const Dali::Layer &)result);
32144   return jresult;
32145 }
32146
32147
32148 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Layer(void * jarg1) {
32149   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32150
32151   arg1 = (Dali::Layer *)jarg1;
32152   {
32153     try {
32154       delete arg1;
32155     } catch (std::out_of_range& e) {
32156       {
32157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32158       };
32159     } catch (std::exception& e) {
32160       {
32161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32166       };
32167     }
32168   }
32169 }
32170
32171
32172 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Layer__SWIG_1(void * jarg1) {
32173   void * jresult ;
32174   Dali::Layer *arg1 = 0 ;
32175   Dali::Layer *result = 0 ;
32176
32177   arg1 = (Dali::Layer *)jarg1;
32178   if (!arg1) {
32179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32180     return 0;
32181   }
32182   {
32183     try {
32184       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32185     } catch (std::out_of_range& e) {
32186       {
32187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32188       };
32189     } catch (std::exception& e) {
32190       {
32191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32192       };
32193     } catch (...) {
32194       {
32195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32196       };
32197     }
32198   }
32199   jresult = (void *)result;
32200   return jresult;
32201 }
32202
32203
32204 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_Assign(void * jarg1, void * jarg2) {
32205   void * jresult ;
32206   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32207   Dali::Layer *arg2 = 0 ;
32208   Dali::Layer *result = 0 ;
32209
32210   arg1 = (Dali::Layer *)jarg1;
32211   arg2 = (Dali::Layer *)jarg2;
32212   if (!arg2) {
32213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32214     return 0;
32215   }
32216   {
32217     try {
32218       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32219     } catch (std::out_of_range& e) {
32220       {
32221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32222       };
32223     } catch (std::exception& e) {
32224       {
32225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32226       };
32227     } catch (...) {
32228       {
32229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32230       };
32231     }
32232   }
32233   jresult = (void *)result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_GetDepth(void * jarg1) {
32239   unsigned int jresult ;
32240   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32241   unsigned int result;
32242
32243   arg1 = (Dali::Layer *)jarg1;
32244   {
32245     try {
32246       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261   jresult = result;
32262   return jresult;
32263 }
32264
32265
32266 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_Raise(void * jarg1) {
32267   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32268
32269   arg1 = (Dali::Layer *)jarg1;
32270   {
32271     try {
32272       (arg1)->Raise();
32273     } catch (std::out_of_range& e) {
32274       {
32275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32276       };
32277     } catch (std::exception& e) {
32278       {
32279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32280       };
32281     } catch (...) {
32282       {
32283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32284       };
32285     }
32286   }
32287 }
32288
32289
32290 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_Lower(void * jarg1) {
32291   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32292
32293   arg1 = (Dali::Layer *)jarg1;
32294   {
32295     try {
32296       (arg1)->Lower();
32297     } catch (std::out_of_range& e) {
32298       {
32299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32300       };
32301     } catch (std::exception& e) {
32302       {
32303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32304       };
32305     } catch (...) {
32306       {
32307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32308       };
32309     }
32310   }
32311 }
32312
32313
32314 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32315   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32316   Dali::Layer arg2 ;
32317   Dali::Layer *argp2 ;
32318
32319   arg1 = (Dali::Layer *)jarg1;
32320   argp2 = (Dali::Layer *)jarg2;
32321   if (!argp2) {
32322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32323     return ;
32324   }
32325   arg2 = *argp2;
32326   {
32327     try {
32328       (arg1)->RaiseAbove(arg2);
32329     } catch (std::out_of_range& e) {
32330       {
32331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32332       };
32333     } catch (std::exception& e) {
32334       {
32335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32336       };
32337     } catch (...) {
32338       {
32339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32340       };
32341     }
32342   }
32343 }
32344
32345
32346 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_LowerBelow(void * jarg1, void * jarg2) {
32347   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32348   Dali::Layer arg2 ;
32349   Dali::Layer *argp2 ;
32350
32351   arg1 = (Dali::Layer *)jarg1;
32352   argp2 = (Dali::Layer *)jarg2;
32353   if (!argp2) {
32354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32355     return ;
32356   }
32357   arg2 = *argp2;
32358   {
32359     try {
32360       (arg1)->LowerBelow(arg2);
32361     } catch (std::out_of_range& e) {
32362       {
32363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32364       };
32365     } catch (std::exception& e) {
32366       {
32367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32368       };
32369     } catch (...) {
32370       {
32371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32372       };
32373     }
32374   }
32375 }
32376
32377
32378 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_RaiseToTop(void * jarg1) {
32379   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32380
32381   arg1 = (Dali::Layer *)jarg1;
32382   {
32383     try {
32384       (arg1)->RaiseToTop();
32385     } catch (std::out_of_range& e) {
32386       {
32387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32388       };
32389     } catch (std::exception& e) {
32390       {
32391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32392       };
32393     } catch (...) {
32394       {
32395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32396       };
32397     }
32398   }
32399 }
32400
32401
32402 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_LowerToBottom(void * jarg1) {
32403   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32404
32405   arg1 = (Dali::Layer *)jarg1;
32406   {
32407     try {
32408       (arg1)->LowerToBottom();
32409     } catch (std::out_of_range& e) {
32410       {
32411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32412       };
32413     } catch (std::exception& e) {
32414       {
32415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32416       };
32417     } catch (...) {
32418       {
32419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32420       };
32421     }
32422   }
32423 }
32424
32425
32426 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_MoveAbove(void * jarg1, void * jarg2) {
32427   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32428   Dali::Layer arg2 ;
32429   Dali::Layer *argp2 ;
32430
32431   arg1 = (Dali::Layer *)jarg1;
32432   argp2 = (Dali::Layer *)jarg2;
32433   if (!argp2) {
32434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32435     return ;
32436   }
32437   arg2 = *argp2;
32438   {
32439     try {
32440       (arg1)->MoveAbove(arg2);
32441     } catch (std::out_of_range& e) {
32442       {
32443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32444       };
32445     } catch (std::exception& e) {
32446       {
32447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32448       };
32449     } catch (...) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32452       };
32453     }
32454   }
32455 }
32456
32457
32458 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_MoveBelow(void * jarg1, void * jarg2) {
32459   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32460   Dali::Layer arg2 ;
32461   Dali::Layer *argp2 ;
32462
32463   arg1 = (Dali::Layer *)jarg1;
32464   argp2 = (Dali::Layer *)jarg2;
32465   if (!argp2) {
32466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32467     return ;
32468   }
32469   arg2 = *argp2;
32470   {
32471     try {
32472       (arg1)->MoveBelow(arg2);
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32480       };
32481     } catch (...) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32484       };
32485     }
32486   }
32487 }
32488
32489
32490 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetBehavior(void * jarg1, int jarg2) {
32491   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32492   Dali::Layer::Behavior arg2 ;
32493
32494   arg1 = (Dali::Layer *)jarg1;
32495   arg2 = (Dali::Layer::Behavior)jarg2;
32496   {
32497     try {
32498       (arg1)->SetBehavior(arg2);
32499     } catch (std::out_of_range& e) {
32500       {
32501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32502       };
32503     } catch (std::exception& e) {
32504       {
32505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32506       };
32507     } catch (...) {
32508       {
32509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32510       };
32511     }
32512   }
32513 }
32514
32515
32516 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Layer_GetBehavior(void * jarg1) {
32517   int jresult ;
32518   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32519   Dali::Layer::Behavior result;
32520
32521   arg1 = (Dali::Layer *)jarg1;
32522   {
32523     try {
32524       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32525     } catch (std::out_of_range& e) {
32526       {
32527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32528       };
32529     } catch (std::exception& e) {
32530       {
32531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32532       };
32533     } catch (...) {
32534       {
32535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32536       };
32537     }
32538   }
32539   jresult = (int)result;
32540   return jresult;
32541 }
32542
32543
32544 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32545   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32546   bool arg2 ;
32547
32548   arg1 = (Dali::Layer *)jarg1;
32549   arg2 = jarg2 ? true : false;
32550   {
32551     try {
32552       (arg1)->SetClipping(arg2);
32553     } catch (std::out_of_range& e) {
32554       {
32555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32556       };
32557     } catch (std::exception& e) {
32558       {
32559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (...) {
32562       {
32563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32564       };
32565     }
32566   }
32567 }
32568
32569
32570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsClipping(void * jarg1) {
32571   unsigned int jresult ;
32572   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32573   bool result;
32574
32575   arg1 = (Dali::Layer *)jarg1;
32576   {
32577     try {
32578       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32579     } catch (std::out_of_range& e) {
32580       {
32581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (std::exception& e) {
32584       {
32585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593   jresult = result;
32594   return jresult;
32595 }
32596
32597
32598 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32599   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32600   int arg2 ;
32601   int arg3 ;
32602   int arg4 ;
32603   int arg5 ;
32604
32605   arg1 = (Dali::Layer *)jarg1;
32606   arg2 = (int)jarg2;
32607   arg3 = (int)jarg3;
32608   arg4 = (int)jarg4;
32609   arg5 = (int)jarg5;
32610   {
32611     try {
32612       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32613     } catch (std::out_of_range& e) {
32614       {
32615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32616       };
32617     } catch (std::exception& e) {
32618       {
32619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32624       };
32625     }
32626   }
32627 }
32628
32629
32630 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
32631   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32632   Dali::ClippingBox arg2 ;
32633   Dali::ClippingBox *argp2 ;
32634
32635   arg1 = (Dali::Layer *)jarg1;
32636   argp2 = (Dali::ClippingBox *)jarg2;
32637   if (!argp2) {
32638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
32639     return ;
32640   }
32641   arg2 = *argp2;
32642   {
32643     try {
32644       (arg1)->SetClippingBox(arg2);
32645     } catch (std::out_of_range& e) {
32646       {
32647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32648       };
32649     } catch (std::exception& e) {
32650       {
32651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32652       };
32653     } catch (...) {
32654       {
32655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32656       };
32657     }
32658   }
32659 }
32660
32661
32662 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Layer_GetClippingBox(void * jarg1) {
32663   void * jresult ;
32664   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32665   Dali::ClippingBox result;
32666
32667   arg1 = (Dali::Layer *)jarg1;
32668   {
32669     try {
32670       result = ((Dali::Layer const *)arg1)->GetClippingBox();
32671     } catch (std::out_of_range& e) {
32672       {
32673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32674       };
32675     } catch (std::exception& e) {
32676       {
32677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32678       };
32679     } catch (...) {
32680       {
32681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32682       };
32683     }
32684   }
32685   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
32686   return jresult;
32687 }
32688
32689
32690 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
32691   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32692   bool arg2 ;
32693
32694   arg1 = (Dali::Layer *)jarg1;
32695   arg2 = jarg2 ? true : false;
32696   {
32697     try {
32698       (arg1)->SetDepthTestDisabled(arg2);
32699     } catch (std::out_of_range& e) {
32700       {
32701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32702       };
32703     } catch (std::exception& e) {
32704       {
32705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (...) {
32708       {
32709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32710       };
32711     }
32712   }
32713 }
32714
32715
32716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsDepthTestDisabled(void * jarg1) {
32717   unsigned int jresult ;
32718   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32719   bool result;
32720
32721   arg1 = (Dali::Layer *)jarg1;
32722   {
32723     try {
32724       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
32725     } catch (std::out_of_range& e) {
32726       {
32727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32728       };
32729     } catch (std::exception& e) {
32730       {
32731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32732       };
32733     } catch (...) {
32734       {
32735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32736       };
32737     }
32738   }
32739   jresult = result;
32740   return jresult;
32741 }
32742
32743
32744 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetSortFunction(void * jarg1, void * jarg2) {
32745   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32746   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
32747
32748   arg1 = (Dali::Layer *)jarg1;
32749   arg2 = (Dali::Layer::SortFunctionType)jarg2;
32750   {
32751     try {
32752       (arg1)->SetSortFunction(arg2);
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32760       };
32761     } catch (...) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32764       };
32765     }
32766   }
32767 }
32768
32769
32770 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
32771   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32772   bool arg2 ;
32773
32774   arg1 = (Dali::Layer *)jarg1;
32775   arg2 = jarg2 ? true : false;
32776   {
32777     try {
32778       (arg1)->SetTouchConsumed(arg2);
32779     } catch (std::out_of_range& e) {
32780       {
32781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32782       };
32783     } catch (std::exception& e) {
32784       {
32785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32786       };
32787     } catch (...) {
32788       {
32789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32790       };
32791     }
32792   }
32793 }
32794
32795
32796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsTouchConsumed(void * jarg1) {
32797   unsigned int jresult ;
32798   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32799   bool result;
32800
32801   arg1 = (Dali::Layer *)jarg1;
32802   {
32803     try {
32804       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
32805     } catch (std::out_of_range& e) {
32806       {
32807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32808       };
32809     } catch (std::exception& e) {
32810       {
32811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32812       };
32813     } catch (...) {
32814       {
32815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32816       };
32817     }
32818   }
32819   jresult = result;
32820   return jresult;
32821 }
32822
32823
32824 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
32825   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32826   bool arg2 ;
32827
32828   arg1 = (Dali::Layer *)jarg1;
32829   arg2 = jarg2 ? true : false;
32830   {
32831     try {
32832       (arg1)->SetHoverConsumed(arg2);
32833     } catch (std::out_of_range& e) {
32834       {
32835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32836       };
32837     } catch (std::exception& e) {
32838       {
32839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32840       };
32841     } catch (...) {
32842       {
32843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32844       };
32845     }
32846   }
32847 }
32848
32849
32850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Layer_IsHoverConsumed(void * jarg1) {
32851   unsigned int jresult ;
32852   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32853   bool result;
32854
32855   arg1 = (Dali::Layer *)jarg1;
32856   {
32857     try {
32858       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
32859     } catch (std::out_of_range& e) {
32860       {
32861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32862       };
32863     } catch (std::exception& e) {
32864       {
32865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32866       };
32867     } catch (...) {
32868       {
32869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32870       };
32871     }
32872   }
32873   jresult = result;
32874   return jresult;
32875 }
32876
32877
32878 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_DEFAULT_BACKGROUND_COLOR_get() {
32879   void * jresult ;
32880   Dali::Vector4 *result = 0 ;
32881
32882   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
32883   jresult = (void *)result;
32884   return jresult;
32885 }
32886
32887
32888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_DEBUG_BACKGROUND_COLOR_get() {
32889   void * jresult ;
32890   Dali::Vector4 *result = 0 ;
32891
32892   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
32893   jresult = (void *)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Stage__SWIG_0() {
32899   void * jresult ;
32900   Dali::Stage *result = 0 ;
32901
32902   {
32903     try {
32904       result = (Dali::Stage *)new Dali::Stage();
32905     } catch (std::out_of_range& e) {
32906       {
32907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32908       };
32909     } catch (std::exception& e) {
32910       {
32911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32912       };
32913     } catch (...) {
32914       {
32915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32916       };
32917     }
32918   }
32919   jresult = (void *)result;
32920   return jresult;
32921 }
32922
32923
32924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetCurrent() {
32925   void * jresult ;
32926   Dali::Stage result;
32927
32928   {
32929     try {
32930       result = Dali::Stage::GetCurrent();
32931     } catch (std::out_of_range& e) {
32932       {
32933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32934       };
32935     } catch (std::exception& e) {
32936       {
32937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32938       };
32939     } catch (...) {
32940       {
32941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32942       };
32943     }
32944   }
32945   jresult = new Dali::Stage((const Dali::Stage &)result);
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Stage_IsInstalled() {
32951   unsigned int jresult ;
32952   bool result;
32953
32954   {
32955     try {
32956       result = (bool)Dali::Stage::IsInstalled();
32957     } catch (std::out_of_range& e) {
32958       {
32959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32960       };
32961     } catch (std::exception& e) {
32962       {
32963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32964       };
32965     } catch (...) {
32966       {
32967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32968       };
32969     }
32970   }
32971   jresult = result;
32972   return jresult;
32973 }
32974
32975
32976 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Stage(void * jarg1) {
32977   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
32978
32979   arg1 = (Dali::Stage *)jarg1;
32980   {
32981     try {
32982       delete arg1;
32983     } catch (std::out_of_range& e) {
32984       {
32985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32986       };
32987     } catch (std::exception& e) {
32988       {
32989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32990       };
32991     } catch (...) {
32992       {
32993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32994       };
32995     }
32996   }
32997 }
32998
32999
33000 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Stage__SWIG_1(void * jarg1) {
33001   void * jresult ;
33002   Dali::Stage *arg1 = 0 ;
33003   Dali::Stage *result = 0 ;
33004
33005   arg1 = (Dali::Stage *)jarg1;
33006   if (!arg1) {
33007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33008     return 0;
33009   }
33010   {
33011     try {
33012       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33013     } catch (std::out_of_range& e) {
33014       {
33015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33016       };
33017     } catch (std::exception& e) {
33018       {
33019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33020       };
33021     } catch (...) {
33022       {
33023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33024       };
33025     }
33026   }
33027   jresult = (void *)result;
33028   return jresult;
33029 }
33030
33031
33032 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_Assign(void * jarg1, void * jarg2) {
33033   void * jresult ;
33034   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33035   Dali::Stage *arg2 = 0 ;
33036   Dali::Stage *result = 0 ;
33037
33038   arg1 = (Dali::Stage *)jarg1;
33039   arg2 = (Dali::Stage *)jarg2;
33040   if (!arg2) {
33041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33042     return 0;
33043   }
33044   {
33045     try {
33046       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33047     } catch (std::out_of_range& e) {
33048       {
33049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33050       };
33051     } catch (std::exception& e) {
33052       {
33053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33054       };
33055     } catch (...) {
33056       {
33057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33058       };
33059     }
33060   }
33061   jresult = (void *)result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_Add(void * jarg1, void * jarg2) {
33067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33068   Dali::Actor *arg2 = 0 ;
33069
33070   arg1 = (Dali::Stage *)jarg1;
33071   arg2 = (Dali::Actor *)jarg2;
33072   if (!arg2) {
33073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33074     return ;
33075   }
33076   {
33077     try {
33078       (arg1)->Add(*arg2);
33079     } catch (std::out_of_range& e) {
33080       {
33081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33082       };
33083     } catch (std::exception& e) {
33084       {
33085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33086       };
33087     } catch (...) {
33088       {
33089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33090       };
33091     }
33092   }
33093 }
33094
33095
33096 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_Remove(void * jarg1, void * jarg2) {
33097   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33098   Dali::Actor *arg2 = 0 ;
33099
33100   arg1 = (Dali::Stage *)jarg1;
33101   arg2 = (Dali::Actor *)jarg2;
33102   if (!arg2) {
33103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33104     return ;
33105   }
33106   {
33107     try {
33108       (arg1)->Remove(*arg2);
33109     } catch (std::out_of_range& e) {
33110       {
33111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33112       };
33113     } catch (std::exception& e) {
33114       {
33115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33116       };
33117     } catch (...) {
33118       {
33119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33120       };
33121     }
33122   }
33123 }
33124
33125
33126 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetSize(void * jarg1) {
33127   void * jresult ;
33128   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33129   Dali::Vector2 result;
33130
33131   arg1 = (Dali::Stage *)jarg1;
33132   {
33133     try {
33134       result = ((Dali::Stage const *)arg1)->GetSize();
33135     } catch (std::out_of_range& e) {
33136       {
33137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33138       };
33139     } catch (std::exception& e) {
33140       {
33141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33142       };
33143     } catch (...) {
33144       {
33145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33146       };
33147     }
33148   }
33149   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33150   return jresult;
33151 }
33152
33153
33154 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetRenderTaskList(void * jarg1) {
33155   void * jresult ;
33156   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33157   Dali::RenderTaskList result;
33158
33159   arg1 = (Dali::Stage *)jarg1;
33160   {
33161     try {
33162       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33163     } catch (std::out_of_range& e) {
33164       {
33165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33166       };
33167     } catch (std::exception& e) {
33168       {
33169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33170       };
33171     } catch (...) {
33172       {
33173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33174       };
33175     }
33176   }
33177   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33178   return jresult;
33179 }
33180
33181
33182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Stage_GetLayerCount(void * jarg1) {
33183   unsigned int jresult ;
33184   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33185   unsigned int result;
33186
33187   arg1 = (Dali::Stage *)jarg1;
33188   {
33189     try {
33190       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33191     } catch (std::out_of_range& e) {
33192       {
33193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33194       };
33195     } catch (std::exception& e) {
33196       {
33197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33198       };
33199     } catch (...) {
33200       {
33201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33202       };
33203     }
33204   }
33205   jresult = result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33211   void * jresult ;
33212   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33213   unsigned int arg2 ;
33214   Dali::Layer result;
33215
33216   arg1 = (Dali::Stage *)jarg1;
33217   arg2 = (unsigned int)jarg2;
33218   {
33219     try {
33220       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33221     } catch (std::out_of_range& e) {
33222       {
33223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33224       };
33225     } catch (std::exception& e) {
33226       {
33227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33228       };
33229     } catch (...) {
33230       {
33231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33232       };
33233     }
33234   }
33235   jresult = new Dali::Layer((const Dali::Layer &)result);
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetRootLayer(void * jarg1) {
33241   void * jresult ;
33242   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33243   Dali::Layer result;
33244
33245   arg1 = (Dali::Stage *)jarg1;
33246   {
33247     try {
33248       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33249     } catch (std::out_of_range& e) {
33250       {
33251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33252       };
33253     } catch (std::exception& e) {
33254       {
33255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33256       };
33257     } catch (...) {
33258       {
33259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33260       };
33261     }
33262   }
33263   jresult = new Dali::Layer((const Dali::Layer &)result);
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33269   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33270   Dali::Vector4 arg2 ;
33271   Dali::Vector4 *argp2 ;
33272
33273   arg1 = (Dali::Stage *)jarg1;
33274   argp2 = (Dali::Vector4 *)jarg2;
33275   if (!argp2) {
33276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33277     return ;
33278   }
33279   arg2 = *argp2;
33280   {
33281     try {
33282       (arg1)->SetBackgroundColor(arg2);
33283     } catch (std::out_of_range& e) {
33284       {
33285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33286       };
33287     } catch (std::exception& e) {
33288       {
33289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33290       };
33291     } catch (...) {
33292       {
33293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33294       };
33295     }
33296   }
33297 }
33298
33299
33300 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetBackgroundColor(void * jarg1) {
33301   void * jresult ;
33302   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33303   Dali::Vector4 result;
33304
33305   arg1 = (Dali::Stage *)jarg1;
33306   {
33307     try {
33308       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33309     } catch (std::out_of_range& e) {
33310       {
33311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33312       };
33313     } catch (std::exception& e) {
33314       {
33315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33316       };
33317     } catch (...) {
33318       {
33319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33320       };
33321     }
33322   }
33323   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33324   return jresult;
33325 }
33326
33327
33328 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetDpi(void * jarg1) {
33329   void * jresult ;
33330   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33331   Dali::Vector2 result;
33332
33333   arg1 = (Dali::Stage *)jarg1;
33334   {
33335     try {
33336       result = ((Dali::Stage const *)arg1)->GetDpi();
33337     } catch (std::out_of_range& e) {
33338       {
33339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33340       };
33341     } catch (std::exception& e) {
33342       {
33343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33344       };
33345     } catch (...) {
33346       {
33347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33348       };
33349     }
33350   }
33351   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33352   return jresult;
33353 }
33354
33355
33356 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_GetObjectRegistry(void * jarg1) {
33357   void * jresult ;
33358   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33359   Dali::ObjectRegistry result;
33360
33361   arg1 = (Dali::Stage *)jarg1;
33362   {
33363     try {
33364       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33365     } catch (std::out_of_range& e) {
33366       {
33367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33368       };
33369     } catch (std::exception& e) {
33370       {
33371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33372       };
33373     } catch (...) {
33374       {
33375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33376       };
33377     }
33378   }
33379   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33380   return jresult;
33381 }
33382
33383
33384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Stage_KeepRendering(void * jarg1, float jarg2) {
33385   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33386   float arg2 ;
33387
33388   arg1 = (Dali::Stage *)jarg1;
33389   arg2 = (float)jarg2;
33390   {
33391     try {
33392       (arg1)->KeepRendering(arg2);
33393     } catch (std::out_of_range& e) {
33394       {
33395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33396       };
33397     } catch (std::exception& e) {
33398       {
33399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33400       };
33401     } catch (...) {
33402       {
33403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33404       };
33405     }
33406   }
33407 }
33408
33409
33410 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_KeyEventSignal(void * jarg1) {
33411   void * jresult ;
33412   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33413   Dali::Stage::KeyEventSignalType *result = 0 ;
33414
33415   arg1 = (Dali::Stage *)jarg1;
33416   {
33417     try {
33418       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33419     } catch (std::out_of_range& e) {
33420       {
33421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33422       };
33423     } catch (std::exception& e) {
33424       {
33425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33426       };
33427     } catch (...) {
33428       {
33429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33430       };
33431     }
33432   }
33433   jresult = (void *)result;
33434   return jresult;
33435 }
33436
33437
33438 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_EventProcessingFinishedSignal(void * jarg1) {
33439   void * jresult ;
33440   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33441   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33442
33443   arg1 = (Dali::Stage *)jarg1;
33444   {
33445     try {
33446       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33447     } catch (std::out_of_range& e) {
33448       {
33449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33450       };
33451     } catch (std::exception& e) {
33452       {
33453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33454       };
33455     } catch (...) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33458       };
33459     }
33460   }
33461   jresult = (void *)result;
33462   return jresult;
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_TouchedSignal(void * jarg1) {
33467   void * jresult ;
33468   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33469   Dali::Stage::TouchedSignalType *result = 0 ;
33470
33471   arg1 = (Dali::Stage *)jarg1;
33472   {
33473     try {
33474       result = (Dali::Stage::TouchedSignalType *) &(arg1)->TouchedSignal();
33475     } catch (std::out_of_range& e) {
33476       {
33477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33478       };
33479     } catch (std::exception& e) {
33480       {
33481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33482       };
33483     } catch (...) {
33484       {
33485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33486       };
33487     }
33488   }
33489   jresult = (void *)result;
33490   return jresult;
33491 }
33492
33493
33494 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_TouchSignal(void * jarg1) {
33495   void * jresult ;
33496   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33497   Dali::Stage::TouchSignalType *result = 0 ;
33498
33499   arg1 = (Dali::Stage *)jarg1;
33500   {
33501     try {
33502       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33503     } catch (std::out_of_range& e) {
33504       {
33505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (std::exception& e) {
33508       {
33509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33514       };
33515     }
33516   }
33517   jresult = (void *)result;
33518   return jresult;
33519 }
33520
33521
33522 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_WheelEventSignal(void * jarg1) {
33523   void * jresult ;
33524   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33525   Dali::Stage::WheelEventSignalType *result = 0 ;
33526
33527   arg1 = (Dali::Stage *)jarg1;
33528   {
33529     try {
33530       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33531     } catch (std::out_of_range& e) {
33532       {
33533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33534       };
33535     } catch (std::exception& e) {
33536       {
33537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33538       };
33539     } catch (...) {
33540       {
33541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33542       };
33543     }
33544   }
33545   jresult = (void *)result;
33546   return jresult;
33547 }
33548
33549
33550 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_ContextLostSignal(void * jarg1) {
33551   void * jresult ;
33552   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33553   Dali::Stage::ContextStatusSignal *result = 0 ;
33554
33555   arg1 = (Dali::Stage *)jarg1;
33556   {
33557     try {
33558       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (...) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33570       };
33571     }
33572   }
33573   jresult = (void *)result;
33574   return jresult;
33575 }
33576
33577
33578 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_ContextRegainedSignal(void * jarg1) {
33579   void * jresult ;
33580   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33581   Dali::Stage::ContextStatusSignal *result = 0 ;
33582
33583   arg1 = (Dali::Stage *)jarg1;
33584   {
33585     try {
33586       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33587     } catch (std::out_of_range& e) {
33588       {
33589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33590       };
33591     } catch (std::exception& e) {
33592       {
33593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33594       };
33595     } catch (...) {
33596       {
33597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33598       };
33599     }
33600   }
33601   jresult = (void *)result;
33602   return jresult;
33603 }
33604
33605
33606 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Stage_SceneCreatedSignal(void * jarg1) {
33607   void * jresult ;
33608   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33609   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33610
33611   arg1 = (Dali::Stage *)jarg1;
33612   {
33613     try {
33614       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33615     } catch (std::out_of_range& e) {
33616       {
33617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (std::exception& e) {
33620       {
33621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629   jresult = (void *)result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RelayoutContainer(void * jarg1) {
33635   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33636
33637   arg1 = (Dali::RelayoutContainer *)jarg1;
33638   {
33639     try {
33640       delete arg1;
33641     } catch (std::out_of_range& e) {
33642       {
33643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33644       };
33645     } catch (std::exception& e) {
33646       {
33647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33648       };
33649     } catch (...) {
33650       {
33651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33652       };
33653     }
33654   }
33655 }
33656
33657
33658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
33659   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33660   Dali::Actor *arg2 = 0 ;
33661   Dali::Vector2 *arg3 = 0 ;
33662
33663   arg1 = (Dali::RelayoutContainer *)jarg1;
33664   arg2 = (Dali::Actor *)jarg2;
33665   if (!arg2) {
33666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33667     return ;
33668   }
33669   arg3 = (Dali::Vector2 *)jarg3;
33670   if (!arg3) {
33671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33672     return ;
33673   }
33674   {
33675     try {
33676       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
33677     } catch (std::out_of_range& e) {
33678       {
33679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33680       };
33681     } catch (std::exception& e) {
33682       {
33683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33688       };
33689     }
33690   }
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActorImpl_Self(void * jarg1) {
33695   void * jresult ;
33696   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33697   Dali::CustomActor result;
33698
33699   arg1 = (Dali::CustomActorImpl *)jarg1;
33700   {
33701     try {
33702       result = ((Dali::CustomActorImpl const *)arg1)->Self();
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33714       };
33715     }
33716   }
33717   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
33718   return jresult;
33719 }
33720
33721
33722 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
33723   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33724   int arg2 ;
33725
33726   arg1 = (Dali::CustomActorImpl *)jarg1;
33727   arg2 = (int)jarg2;
33728   {
33729     try {
33730       (arg1)->OnStageConnection(arg2);
33731     } catch (std::out_of_range& e) {
33732       {
33733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33734       };
33735     } catch (std::exception& e) {
33736       {
33737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33742       };
33743     }
33744   }
33745 }
33746
33747
33748 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnStageDisconnection(void * jarg1) {
33749   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33750
33751   arg1 = (Dali::CustomActorImpl *)jarg1;
33752   {
33753     try {
33754       (arg1)->OnStageDisconnection();
33755     } catch (std::out_of_range& e) {
33756       {
33757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33758       };
33759     } catch (std::exception& e) {
33760       {
33761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33762       };
33763     } catch (...) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33766       };
33767     }
33768   }
33769 }
33770
33771
33772 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
33773   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33774   Dali::Actor *arg2 = 0 ;
33775
33776   arg1 = (Dali::CustomActorImpl *)jarg1;
33777   arg2 = (Dali::Actor *)jarg2;
33778   if (!arg2) {
33779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33780     return ;
33781   }
33782   {
33783     try {
33784       (arg1)->OnChildAdd(*arg2);
33785     } catch (std::out_of_range& e) {
33786       {
33787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33788       };
33789     } catch (std::exception& e) {
33790       {
33791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33792       };
33793     } catch (...) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33796       };
33797     }
33798   }
33799 }
33800
33801
33802 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
33803   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33804   Dali::Actor *arg2 = 0 ;
33805
33806   arg1 = (Dali::CustomActorImpl *)jarg1;
33807   arg2 = (Dali::Actor *)jarg2;
33808   if (!arg2) {
33809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33810     return ;
33811   }
33812   {
33813     try {
33814       (arg1)->OnChildRemove(*arg2);
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33822       };
33823     } catch (...) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33826       };
33827     }
33828   }
33829 }
33830
33831
33832 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
33833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33834   Dali::Property::Index arg2 ;
33835   Dali::Property::Value arg3 ;
33836   Dali::Property::Value *argp3 ;
33837
33838   arg1 = (Dali::CustomActorImpl *)jarg1;
33839   arg2 = (Dali::Property::Index)jarg2;
33840   argp3 = (Dali::Property::Value *)jarg3;
33841   if (!argp3) {
33842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
33843     return ;
33844   }
33845   arg3 = *argp3;
33846   {
33847     try {
33848       (arg1)->OnPropertySet(arg2,arg3);
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33860       };
33861     }
33862   }
33863 }
33864
33865
33866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
33867   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33868   Dali::Vector3 *arg2 = 0 ;
33869
33870   arg1 = (Dali::CustomActorImpl *)jarg1;
33871   arg2 = (Dali::Vector3 *)jarg2;
33872   if (!arg2) {
33873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33874     return ;
33875   }
33876   {
33877     try {
33878       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
33879     } catch (std::out_of_range& e) {
33880       {
33881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33882       };
33883     } catch (std::exception& e) {
33884       {
33885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33886       };
33887     } catch (...) {
33888       {
33889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33890       };
33891     }
33892   }
33893 }
33894
33895
33896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
33897   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33898   Dali::Animation *arg2 = 0 ;
33899   Dali::Vector3 *arg3 = 0 ;
33900
33901   arg1 = (Dali::CustomActorImpl *)jarg1;
33902   arg2 = (Dali::Animation *)jarg2;
33903   if (!arg2) {
33904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
33905     return ;
33906   }
33907   arg3 = (Dali::Vector3 *)jarg3;
33908   if (!arg3) {
33909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33910     return ;
33911   }
33912   {
33913     try {
33914       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
33915     } catch (std::out_of_range& e) {
33916       {
33917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33918       };
33919     } catch (std::exception& e) {
33920       {
33921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33922       };
33923     } catch (...) {
33924       {
33925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33926       };
33927     }
33928   }
33929 }
33930
33931
33932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
33933   unsigned int jresult ;
33934   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33935   Dali::TouchEvent *arg2 = 0 ;
33936   bool result;
33937
33938   arg1 = (Dali::CustomActorImpl *)jarg1;
33939   arg2 = (Dali::TouchEvent *)jarg2;
33940   if (!arg2) {
33941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
33942     return 0;
33943   }
33944   {
33945     try {
33946       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
33947     } catch (std::out_of_range& e) {
33948       {
33949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (std::exception& e) {
33952       {
33953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33954       };
33955     } catch (...) {
33956       {
33957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33958       };
33959     }
33960   }
33961   jresult = result;
33962   return jresult;
33963 }
33964
33965
33966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
33967   unsigned int jresult ;
33968   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33969   Dali::HoverEvent *arg2 = 0 ;
33970   bool result;
33971
33972   arg1 = (Dali::CustomActorImpl *)jarg1;
33973   arg2 = (Dali::HoverEvent *)jarg2;
33974   if (!arg2) {
33975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
33976     return 0;
33977   }
33978   {
33979     try {
33980       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
33981     } catch (std::out_of_range& e) {
33982       {
33983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33984       };
33985     } catch (std::exception& e) {
33986       {
33987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (...) {
33990       {
33991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33992       };
33993     }
33994   }
33995   jresult = result;
33996   return jresult;
33997 }
33998
33999
34000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34001   unsigned int jresult ;
34002   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34003   Dali::KeyEvent *arg2 = 0 ;
34004   bool result;
34005
34006   arg1 = (Dali::CustomActorImpl *)jarg1;
34007   arg2 = (Dali::KeyEvent *)jarg2;
34008   if (!arg2) {
34009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34010     return 0;
34011   }
34012   {
34013     try {
34014       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (...) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34026       };
34027     }
34028   }
34029   jresult = result;
34030   return jresult;
34031 }
34032
34033
34034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34035   unsigned int jresult ;
34036   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34037   Dali::WheelEvent *arg2 = 0 ;
34038   bool result;
34039
34040   arg1 = (Dali::CustomActorImpl *)jarg1;
34041   arg2 = (Dali::WheelEvent *)jarg2;
34042   if (!arg2) {
34043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34044     return 0;
34045   }
34046   {
34047     try {
34048       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34049     } catch (std::out_of_range& e) {
34050       {
34051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34052       };
34053     } catch (std::exception& e) {
34054       {
34055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34056       };
34057     } catch (...) {
34058       {
34059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34060       };
34061     }
34062   }
34063   jresult = result;
34064   return jresult;
34065 }
34066
34067
34068 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34069   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34070   Dali::Vector2 *arg2 = 0 ;
34071   Dali::RelayoutContainer *arg3 = 0 ;
34072
34073   arg1 = (Dali::CustomActorImpl *)jarg1;
34074   arg2 = (Dali::Vector2 *)jarg2;
34075   if (!arg2) {
34076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34077     return ;
34078   }
34079   arg3 = (Dali::RelayoutContainer *)jarg3;
34080   if (!arg3) {
34081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34082     return ;
34083   }
34084   {
34085     try {
34086       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34087     } catch (std::out_of_range& e) {
34088       {
34089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34090       };
34091     } catch (std::exception& e) {
34092       {
34093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34094       };
34095     } catch (...) {
34096       {
34097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34098       };
34099     }
34100   }
34101 }
34102
34103
34104 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34105   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34106   Dali::ResizePolicy::Type arg2 ;
34107   Dali::Dimension::Type arg3 ;
34108
34109   arg1 = (Dali::CustomActorImpl *)jarg1;
34110   arg2 = (Dali::ResizePolicy::Type)jarg2;
34111   arg3 = (Dali::Dimension::Type)jarg3;
34112   {
34113     try {
34114       (arg1)->OnSetResizePolicy(arg2,arg3);
34115     } catch (std::out_of_range& e) {
34116       {
34117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34118       };
34119     } catch (std::exception& e) {
34120       {
34121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34122       };
34123     } catch (...) {
34124       {
34125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34126       };
34127     }
34128   }
34129 }
34130
34131
34132 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetNaturalSize(void * jarg1) {
34133   void * jresult ;
34134   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34135   Dali::Vector3 result;
34136
34137   arg1 = (Dali::CustomActorImpl *)jarg1;
34138   {
34139     try {
34140       result = (arg1)->GetNaturalSize();
34141     } catch (std::out_of_range& e) {
34142       {
34143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34144       };
34145     } catch (std::exception& e) {
34146       {
34147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34148       };
34149     } catch (...) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34152       };
34153     }
34154   }
34155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34156   return jresult;
34157 }
34158
34159
34160 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34161   float jresult ;
34162   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34163   Dali::Actor *arg2 = 0 ;
34164   Dali::Dimension::Type arg3 ;
34165   float result;
34166
34167   arg1 = (Dali::CustomActorImpl *)jarg1;
34168   arg2 = (Dali::Actor *)jarg2;
34169   if (!arg2) {
34170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34171     return 0;
34172   }
34173   arg3 = (Dali::Dimension::Type)jarg3;
34174   {
34175     try {
34176       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34177     } catch (std::out_of_range& e) {
34178       {
34179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34180       };
34181     } catch (std::exception& e) {
34182       {
34183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34184       };
34185     } catch (...) {
34186       {
34187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34188       };
34189     }
34190   }
34191   jresult = result;
34192   return jresult;
34193 }
34194
34195
34196 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34197   float jresult ;
34198   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34199   float arg2 ;
34200   float result;
34201
34202   arg1 = (Dali::CustomActorImpl *)jarg1;
34203   arg2 = (float)jarg2;
34204   {
34205     try {
34206       result = (float)(arg1)->GetHeightForWidth(arg2);
34207     } catch (std::out_of_range& e) {
34208       {
34209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34210       };
34211     } catch (std::exception& e) {
34212       {
34213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34214       };
34215     } catch (...) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34218       };
34219     }
34220   }
34221   jresult = result;
34222   return jresult;
34223 }
34224
34225
34226 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34227   float jresult ;
34228   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34229   float arg2 ;
34230   float result;
34231
34232   arg1 = (Dali::CustomActorImpl *)jarg1;
34233   arg2 = (float)jarg2;
34234   {
34235     try {
34236       result = (float)(arg1)->GetWidthForHeight(arg2);
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34244       };
34245     } catch (...) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34248       };
34249     }
34250   }
34251   jresult = result;
34252   return jresult;
34253 }
34254
34255
34256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34257   unsigned int jresult ;
34258   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34259   Dali::Dimension::Type arg2 ;
34260   bool result;
34261
34262   arg1 = (Dali::CustomActorImpl *)jarg1;
34263   arg2 = (Dali::Dimension::Type)jarg2;
34264   {
34265     try {
34266       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34274       };
34275     } catch (...) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34278       };
34279     }
34280   }
34281   jresult = result;
34282   return jresult;
34283 }
34284
34285
34286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34287   unsigned int jresult ;
34288   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34289   bool result;
34290
34291   arg1 = (Dali::CustomActorImpl *)jarg1;
34292   {
34293     try {
34294       result = (bool)(arg1)->RelayoutDependentOnChildren();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34302       };
34303     } catch (...) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34306       };
34307     }
34308   }
34309   jresult = result;
34310   return jresult;
34311 }
34312
34313
34314 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34315   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34316   Dali::Dimension::Type arg2 ;
34317
34318   arg1 = (Dali::CustomActorImpl *)jarg1;
34319   arg2 = (Dali::Dimension::Type)jarg2;
34320   {
34321     try {
34322       (arg1)->OnCalculateRelayoutSize(arg2);
34323     } catch (std::out_of_range& e) {
34324       {
34325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34326       };
34327     } catch (std::exception& e) {
34328       {
34329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34330       };
34331     } catch (...) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34334       };
34335     }
34336   }
34337 }
34338
34339
34340 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34341   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34342   float arg2 ;
34343   Dali::Dimension::Type arg3 ;
34344
34345   arg1 = (Dali::CustomActorImpl *)jarg1;
34346   arg2 = (float)jarg2;
34347   arg3 = (Dali::Dimension::Type)jarg3;
34348   {
34349     try {
34350       (arg1)->OnLayoutNegotiated(arg2,arg3);
34351     } catch (std::out_of_range& e) {
34352       {
34353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34354       };
34355     } catch (std::exception& e) {
34356       {
34357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34358       };
34359     } catch (...) {
34360       {
34361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34362       };
34363     }
34364   }
34365 }
34366
34367
34368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34369   unsigned int jresult ;
34370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34371   bool result;
34372
34373   arg1 = (Dali::CustomActorImpl *)jarg1;
34374   {
34375     try {
34376       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34377     } catch (std::out_of_range& e) {
34378       {
34379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34380       };
34381     } catch (std::exception& e) {
34382       {
34383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34384       };
34385     } catch (...) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34388       };
34389     }
34390   }
34391   jresult = result;
34392   return jresult;
34393 }
34394
34395
34396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34397   unsigned int jresult ;
34398   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34399   bool result;
34400
34401   arg1 = (Dali::CustomActorImpl *)jarg1;
34402   {
34403     try {
34404       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34405     } catch (std::out_of_range& e) {
34406       {
34407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34408       };
34409     } catch (std::exception& e) {
34410       {
34411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34412       };
34413     } catch (...) {
34414       {
34415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34416       };
34417     }
34418   }
34419   jresult = result;
34420   return jresult;
34421 }
34422
34423
34424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34425   unsigned int jresult ;
34426   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34427   bool result;
34428
34429   arg1 = (Dali::CustomActorImpl *)jarg1;
34430   {
34431     try {
34432       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34433     } catch (std::out_of_range& e) {
34434       {
34435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34436       };
34437     } catch (std::exception& e) {
34438       {
34439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (...) {
34442       {
34443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34444       };
34445     }
34446   }
34447   jresult = result;
34448   return jresult;
34449 }
34450
34451
34452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34453   unsigned int jresult ;
34454   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34455   bool result;
34456
34457   arg1 = (Dali::CustomActorImpl *)jarg1;
34458   {
34459     try {
34460       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34461     } catch (std::out_of_range& e) {
34462       {
34463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34464       };
34465     } catch (std::exception& e) {
34466       {
34467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34468       };
34469     } catch (...) {
34470       {
34471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34472       };
34473     }
34474   }
34475   jresult = result;
34476   return jresult;
34477 }
34478
34479
34480 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_0() {
34481   void * jresult ;
34482   Dali::CustomActor *result = 0 ;
34483
34484   {
34485     try {
34486       result = (Dali::CustomActor *)new Dali::CustomActor();
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = (void *)result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_DownCast(void * jarg1) {
34507   void * jresult ;
34508   Dali::BaseHandle arg1 ;
34509   Dali::BaseHandle *argp1 ;
34510   Dali::CustomActor result;
34511
34512   argp1 = (Dali::BaseHandle *)jarg1;
34513   if (!argp1) {
34514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34515     return 0;
34516   }
34517   arg1 = *argp1;
34518   {
34519     try {
34520       result = Dali::CustomActor::DownCast(arg1);
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34528       };
34529     } catch (...) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34532       };
34533     }
34534   }
34535   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34536   return jresult;
34537 }
34538
34539
34540 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CustomActor(void * jarg1) {
34541   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34542
34543   arg1 = (Dali::CustomActor *)jarg1;
34544   {
34545     try {
34546       delete arg1;
34547     } catch (std::out_of_range& e) {
34548       {
34549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34550       };
34551     } catch (std::exception& e) {
34552       {
34553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34554       };
34555     } catch (...) {
34556       {
34557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34558       };
34559     }
34560   }
34561 }
34562
34563
34564 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_GetImplementation(void * jarg1) {
34565   void * jresult ;
34566   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34567   Dali::CustomActorImpl *result = 0 ;
34568
34569   arg1 = (Dali::CustomActor *)jarg1;
34570   {
34571     try {
34572       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34573     } catch (std::out_of_range& e) {
34574       {
34575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34576       };
34577     } catch (std::exception& e) {
34578       {
34579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34580       };
34581     } catch (...) {
34582       {
34583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34584       };
34585     }
34586   }
34587   jresult = (void *)result;
34588   return jresult;
34589 }
34590
34591
34592 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_1(void * jarg1) {
34593   void * jresult ;
34594   Dali::CustomActorImpl *arg1 = 0 ;
34595   Dali::CustomActor *result = 0 ;
34596
34597   arg1 = (Dali::CustomActorImpl *)jarg1;
34598   if (!arg1) {
34599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34600     return 0;
34601   }
34602   {
34603     try {
34604       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34605     } catch (std::out_of_range& e) {
34606       {
34607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34608       };
34609     } catch (std::exception& e) {
34610       {
34611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34612       };
34613     } catch (...) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34616       };
34617     }
34618   }
34619   jresult = (void *)result;
34620   return jresult;
34621 }
34622
34623
34624 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CustomActor__SWIG_2(void * jarg1) {
34625   void * jresult ;
34626   Dali::CustomActor *arg1 = 0 ;
34627   Dali::CustomActor *result = 0 ;
34628
34629   arg1 = (Dali::CustomActor *)jarg1;
34630   if (!arg1) {
34631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34632     return 0;
34633   }
34634   {
34635     try {
34636       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34637     } catch (std::out_of_range& e) {
34638       {
34639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34640       };
34641     } catch (std::exception& e) {
34642       {
34643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34644       };
34645     } catch (...) {
34646       {
34647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34648       };
34649     }
34650   }
34651   jresult = (void *)result;
34652   return jresult;
34653 }
34654
34655
34656 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CustomActor_Assign(void * jarg1, void * jarg2) {
34657   void * jresult ;
34658   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34659   Dali::CustomActor *arg2 = 0 ;
34660   Dali::CustomActor *result = 0 ;
34661
34662   arg1 = (Dali::CustomActor *)jarg1;
34663   arg2 = (Dali::CustomActor *)jarg2;
34664   if (!arg2) {
34665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34666     return 0;
34667   }
34668   {
34669     try {
34670       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34678       };
34679     } catch (...) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34682       };
34683     }
34684   }
34685   jresult = (void *)result;
34686   return jresult;
34687 }
34688
34689
34690 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_POSITION_get() {
34691   int jresult ;
34692   int result;
34693
34694   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
34695   jresult = (int)result;
34696   return jresult;
34697 }
34698
34699
34700 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
34701   int jresult ;
34702   int result;
34703
34704   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
34705   jresult = (int)result;
34706   return jresult;
34707 }
34708
34709
34710 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
34711   int jresult ;
34712   int result;
34713
34714   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
34715   jresult = (int)result;
34716   return jresult;
34717 }
34718
34719
34720 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_POSITION_get() {
34721   int jresult ;
34722   int result;
34723
34724   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
34725   jresult = (int)result;
34726   return jresult;
34727 }
34728
34729
34730 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
34731   int jresult ;
34732   int result;
34733
34734   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
34735   jresult = (int)result;
34736   return jresult;
34737 }
34738
34739
34740 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
34741   int jresult ;
34742   int result;
34743
34744   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
34745   jresult = (int)result;
34746   return jresult;
34747 }
34748
34749
34750 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PanGestureDetector_Property_PANNING_get() {
34751   int jresult ;
34752   int result;
34753
34754   result = (int)Dali::PanGestureDetector::Property::PANNING;
34755   jresult = (int)result;
34756   return jresult;
34757 }
34758
34759
34760 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector_Property() {
34761   void * jresult ;
34762   Dali::PanGestureDetector::Property *result = 0 ;
34763
34764   {
34765     try {
34766       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
34767     } catch (std::out_of_range& e) {
34768       {
34769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34770       };
34771     } catch (std::exception& e) {
34772       {
34773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34774       };
34775     } catch (...) {
34776       {
34777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34778       };
34779     }
34780   }
34781   jresult = (void *)result;
34782   return jresult;
34783 }
34784
34785
34786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetector_Property(void * jarg1) {
34787   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
34788
34789   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
34790   {
34791     try {
34792       delete arg1;
34793     } catch (std::out_of_range& e) {
34794       {
34795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (std::exception& e) {
34798       {
34799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34800       };
34801     } catch (...) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34804       };
34805     }
34806   }
34807 }
34808
34809
34810 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_LEFT_get() {
34811   void * jresult ;
34812   Dali::Radian *result = 0 ;
34813
34814   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
34815   jresult = (void *)result;
34816   return jresult;
34817 }
34818
34819
34820 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_RIGHT_get() {
34821   void * jresult ;
34822   Dali::Radian *result = 0 ;
34823
34824   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
34825   jresult = (void *)result;
34826   return jresult;
34827 }
34828
34829
34830 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_UP_get() {
34831   void * jresult ;
34832   Dali::Radian *result = 0 ;
34833
34834   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
34835   jresult = (void *)result;
34836   return jresult;
34837 }
34838
34839
34840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_DOWN_get() {
34841   void * jresult ;
34842   Dali::Radian *result = 0 ;
34843
34844   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
34845   jresult = (void *)result;
34846   return jresult;
34847 }
34848
34849
34850 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
34851   void * jresult ;
34852   Dali::Radian *result = 0 ;
34853
34854   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
34855   jresult = (void *)result;
34856   return jresult;
34857 }
34858
34859
34860 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DIRECTION_VERTICAL_get() {
34861   void * jresult ;
34862   Dali::Radian *result = 0 ;
34863
34864   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
34865   jresult = (void *)result;
34866   return jresult;
34867 }
34868
34869
34870 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DEFAULT_THRESHOLD_get() {
34871   void * jresult ;
34872   Dali::Radian *result = 0 ;
34873
34874   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
34875   jresult = (void *)result;
34876   return jresult;
34877 }
34878
34879
34880 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector__SWIG_0() {
34881   void * jresult ;
34882   Dali::PanGestureDetector *result = 0 ;
34883
34884   {
34885     try {
34886       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
34887     } catch (std::out_of_range& e) {
34888       {
34889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34890       };
34891     } catch (std::exception& e) {
34892       {
34893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34894       };
34895     } catch (...) {
34896       {
34897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34898       };
34899     }
34900   }
34901   jresult = (void *)result;
34902   return jresult;
34903 }
34904
34905
34906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_New() {
34907   void * jresult ;
34908   Dali::PanGestureDetector result;
34909
34910   {
34911     try {
34912       result = Dali::PanGestureDetector::New();
34913     } catch (std::out_of_range& e) {
34914       {
34915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34916       };
34917     } catch (std::exception& e) {
34918       {
34919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (...) {
34922       {
34923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34924       };
34925     }
34926   }
34927   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
34928   return jresult;
34929 }
34930
34931
34932 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DownCast(void * jarg1) {
34933   void * jresult ;
34934   Dali::BaseHandle arg1 ;
34935   Dali::BaseHandle *argp1 ;
34936   Dali::PanGestureDetector result;
34937
34938   argp1 = (Dali::BaseHandle *)jarg1;
34939   if (!argp1) {
34940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34941     return 0;
34942   }
34943   arg1 = *argp1;
34944   {
34945     try {
34946       result = Dali::PanGestureDetector::DownCast(arg1);
34947     } catch (std::out_of_range& e) {
34948       {
34949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34950       };
34951     } catch (std::exception& e) {
34952       {
34953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34954       };
34955     } catch (...) {
34956       {
34957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34958       };
34959     }
34960   }
34961   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
34962   return jresult;
34963 }
34964
34965
34966 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetector(void * jarg1) {
34967   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
34968
34969   arg1 = (Dali::PanGestureDetector *)jarg1;
34970   {
34971     try {
34972       delete arg1;
34973     } catch (std::out_of_range& e) {
34974       {
34975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34976       };
34977     } catch (std::exception& e) {
34978       {
34979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34980       };
34981     } catch (...) {
34982       {
34983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34984       };
34985     }
34986   }
34987 }
34988
34989
34990 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetector__SWIG_1(void * jarg1) {
34991   void * jresult ;
34992   Dali::PanGestureDetector *arg1 = 0 ;
34993   Dali::PanGestureDetector *result = 0 ;
34994
34995   arg1 = (Dali::PanGestureDetector *)jarg1;
34996   if (!arg1) {
34997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
34998     return 0;
34999   }
35000   {
35001     try {
35002       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35003     } catch (std::out_of_range& e) {
35004       {
35005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35006       };
35007     } catch (std::exception& e) {
35008       {
35009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35010       };
35011     } catch (...) {
35012       {
35013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35014       };
35015     }
35016   }
35017   jresult = (void *)result;
35018   return jresult;
35019 }
35020
35021
35022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35023   void * jresult ;
35024   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35025   Dali::PanGestureDetector *arg2 = 0 ;
35026   Dali::PanGestureDetector *result = 0 ;
35027
35028   arg1 = (Dali::PanGestureDetector *)jarg1;
35029   arg2 = (Dali::PanGestureDetector *)jarg2;
35030   if (!arg2) {
35031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35032     return 0;
35033   }
35034   {
35035     try {
35036       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35037     } catch (std::out_of_range& e) {
35038       {
35039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35040       };
35041     } catch (std::exception& e) {
35042       {
35043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35044       };
35045     } catch (...) {
35046       {
35047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35048       };
35049     }
35050   }
35051   jresult = (void *)result;
35052   return jresult;
35053 }
35054
35055
35056 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35057   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35058   unsigned int arg2 ;
35059
35060   arg1 = (Dali::PanGestureDetector *)jarg1;
35061   arg2 = (unsigned int)jarg2;
35062   {
35063     try {
35064       (arg1)->SetMinimumTouchesRequired(arg2);
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (...) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35076       };
35077     }
35078   }
35079 }
35080
35081
35082 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35083   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35084   unsigned int arg2 ;
35085
35086   arg1 = (Dali::PanGestureDetector *)jarg1;
35087   arg2 = (unsigned int)jarg2;
35088   {
35089     try {
35090       (arg1)->SetMaximumTouchesRequired(arg2);
35091     } catch (std::out_of_range& e) {
35092       {
35093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (std::exception& e) {
35096       {
35097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35098       };
35099     } catch (...) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35102       };
35103     }
35104   }
35105 }
35106
35107
35108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35109   unsigned int jresult ;
35110   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35111   unsigned int result;
35112
35113   arg1 = (Dali::PanGestureDetector *)jarg1;
35114   {
35115     try {
35116       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35117     } catch (std::out_of_range& e) {
35118       {
35119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35120       };
35121     } catch (std::exception& e) {
35122       {
35123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35124       };
35125     } catch (...) {
35126       {
35127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35128       };
35129     }
35130   }
35131   jresult = result;
35132   return jresult;
35133 }
35134
35135
35136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35137   unsigned int jresult ;
35138   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35139   unsigned int result;
35140
35141   arg1 = (Dali::PanGestureDetector *)jarg1;
35142   {
35143     try {
35144       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35145     } catch (std::out_of_range& e) {
35146       {
35147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35148       };
35149     } catch (std::exception& e) {
35150       {
35151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35156       };
35157     }
35158   }
35159   jresult = result;
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35165   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35166   Dali::Radian arg2 ;
35167   Dali::Radian arg3 ;
35168   Dali::Radian *argp2 ;
35169   Dali::Radian *argp3 ;
35170
35171   arg1 = (Dali::PanGestureDetector *)jarg1;
35172   argp2 = (Dali::Radian *)jarg2;
35173   if (!argp2) {
35174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35175     return ;
35176   }
35177   arg2 = *argp2;
35178   argp3 = (Dali::Radian *)jarg3;
35179   if (!argp3) {
35180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35181     return ;
35182   }
35183   arg3 = *argp3;
35184   {
35185     try {
35186       (arg1)->AddAngle(arg2,arg3);
35187     } catch (std::out_of_range& e) {
35188       {
35189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35190       };
35191     } catch (std::exception& e) {
35192       {
35193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35194       };
35195     } catch (...) {
35196       {
35197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35198       };
35199     }
35200   }
35201 }
35202
35203
35204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35205   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35206   Dali::Radian arg2 ;
35207   Dali::Radian *argp2 ;
35208
35209   arg1 = (Dali::PanGestureDetector *)jarg1;
35210   argp2 = (Dali::Radian *)jarg2;
35211   if (!argp2) {
35212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35213     return ;
35214   }
35215   arg2 = *argp2;
35216   {
35217     try {
35218       (arg1)->AddAngle(arg2);
35219     } catch (std::out_of_range& e) {
35220       {
35221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35222       };
35223     } catch (std::exception& e) {
35224       {
35225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35226       };
35227     } catch (...) {
35228       {
35229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35230       };
35231     }
35232   }
35233 }
35234
35235
35236 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35237   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35238   Dali::Radian arg2 ;
35239   Dali::Radian arg3 ;
35240   Dali::Radian *argp2 ;
35241   Dali::Radian *argp3 ;
35242
35243   arg1 = (Dali::PanGestureDetector *)jarg1;
35244   argp2 = (Dali::Radian *)jarg2;
35245   if (!argp2) {
35246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35247     return ;
35248   }
35249   arg2 = *argp2;
35250   argp3 = (Dali::Radian *)jarg3;
35251   if (!argp3) {
35252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35253     return ;
35254   }
35255   arg3 = *argp3;
35256   {
35257     try {
35258       (arg1)->AddDirection(arg2,arg3);
35259     } catch (std::out_of_range& e) {
35260       {
35261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35262       };
35263     } catch (std::exception& e) {
35264       {
35265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35266       };
35267     } catch (...) {
35268       {
35269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35270       };
35271     }
35272   }
35273 }
35274
35275
35276 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35277   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35278   Dali::Radian arg2 ;
35279   Dali::Radian *argp2 ;
35280
35281   arg1 = (Dali::PanGestureDetector *)jarg1;
35282   argp2 = (Dali::Radian *)jarg2;
35283   if (!argp2) {
35284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35285     return ;
35286   }
35287   arg2 = *argp2;
35288   {
35289     try {
35290       (arg1)->AddDirection(arg2);
35291     } catch (std::out_of_range& e) {
35292       {
35293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35294       };
35295     } catch (std::exception& e) {
35296       {
35297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35298       };
35299     } catch (...) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35302       };
35303     }
35304   }
35305 }
35306
35307
35308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetAngleCount(void * jarg1) {
35309   unsigned long jresult ;
35310   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35311   size_t result;
35312
35313   arg1 = (Dali::PanGestureDetector *)jarg1;
35314   {
35315     try {
35316       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35317     } catch (std::out_of_range& e) {
35318       {
35319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35320       };
35321     } catch (std::exception& e) {
35322       {
35323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35324       };
35325     } catch (...) {
35326       {
35327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35328       };
35329     }
35330   }
35331   jresult = (unsigned long)result;
35332   return jresult;
35333 }
35334
35335
35336 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35337   void * jresult ;
35338   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35339   size_t arg2 ;
35340   Dali::PanGestureDetector::AngleThresholdPair result;
35341
35342   arg1 = (Dali::PanGestureDetector *)jarg1;
35343   arg2 = (size_t)jarg2;
35344   {
35345     try {
35346       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35347     } catch (std::out_of_range& e) {
35348       {
35349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35350       };
35351     } catch (std::exception& e) {
35352       {
35353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35354       };
35355     } catch (...) {
35356       {
35357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35358       };
35359     }
35360   }
35361   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35362   return jresult;
35363 }
35364
35365
35366 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_ClearAngles(void * jarg1) {
35367   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35368
35369   arg1 = (Dali::PanGestureDetector *)jarg1;
35370   {
35371     try {
35372       (arg1)->ClearAngles();
35373     } catch (std::out_of_range& e) {
35374       {
35375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35376       };
35377     } catch (std::exception& e) {
35378       {
35379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35380       };
35381     } catch (...) {
35382       {
35383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35384       };
35385     }
35386   }
35387 }
35388
35389
35390 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35391   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35392   Dali::Radian arg2 ;
35393   Dali::Radian *argp2 ;
35394
35395   arg1 = (Dali::PanGestureDetector *)jarg1;
35396   argp2 = (Dali::Radian *)jarg2;
35397   if (!argp2) {
35398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35399     return ;
35400   }
35401   arg2 = *argp2;
35402   {
35403     try {
35404       (arg1)->RemoveAngle(arg2);
35405     } catch (std::out_of_range& e) {
35406       {
35407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35408       };
35409     } catch (std::exception& e) {
35410       {
35411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35412       };
35413     } catch (...) {
35414       {
35415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35416       };
35417     }
35418   }
35419 }
35420
35421
35422 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35423   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35424   Dali::Radian arg2 ;
35425   Dali::Radian *argp2 ;
35426
35427   arg1 = (Dali::PanGestureDetector *)jarg1;
35428   argp2 = (Dali::Radian *)jarg2;
35429   if (!argp2) {
35430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35431     return ;
35432   }
35433   arg2 = *argp2;
35434   {
35435     try {
35436       (arg1)->RemoveDirection(arg2);
35437     } catch (std::out_of_range& e) {
35438       {
35439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35440       };
35441     } catch (std::exception& e) {
35442       {
35443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35444       };
35445     } catch (...) {
35446       {
35447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35448       };
35449     }
35450   }
35451 }
35452
35453
35454 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGestureDetector_DetectedSignal(void * jarg1) {
35455   void * jresult ;
35456   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35457   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35458
35459   arg1 = (Dali::PanGestureDetector *)jarg1;
35460   {
35461     try {
35462       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35463     } catch (std::out_of_range& e) {
35464       {
35465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35466       };
35467     } catch (std::exception& e) {
35468       {
35469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35470       };
35471     } catch (...) {
35472       {
35473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35474       };
35475     }
35476   }
35477   jresult = (void *)result;
35478   return jresult;
35479 }
35480
35481
35482 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35483   Dali::PanGesture *arg1 = 0 ;
35484
35485   arg1 = (Dali::PanGesture *)jarg1;
35486   if (!arg1) {
35487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35488     return ;
35489   }
35490   {
35491     try {
35492       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35493     } catch (std::out_of_range& e) {
35494       {
35495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35496       };
35497     } catch (std::exception& e) {
35498       {
35499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35500       };
35501     } catch (...) {
35502       {
35503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35504       };
35505     }
35506   }
35507 }
35508
35509
35510 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_0() {
35511   void * jresult ;
35512   Dali::PanGesture *result = 0 ;
35513
35514   {
35515     try {
35516       result = (Dali::PanGesture *)new Dali::PanGesture();
35517     } catch (std::out_of_range& e) {
35518       {
35519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35520       };
35521     } catch (std::exception& e) {
35522       {
35523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35524       };
35525     } catch (...) {
35526       {
35527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35528       };
35529     }
35530   }
35531   jresult = (void *)result;
35532   return jresult;
35533 }
35534
35535
35536 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_1(int jarg1) {
35537   void * jresult ;
35538   Dali::Gesture::State arg1 ;
35539   Dali::PanGesture *result = 0 ;
35540
35541   arg1 = (Dali::Gesture::State)jarg1;
35542   {
35543     try {
35544       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35545     } catch (std::out_of_range& e) {
35546       {
35547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35548       };
35549     } catch (std::exception& e) {
35550       {
35551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35552       };
35553     } catch (...) {
35554       {
35555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35556       };
35557     }
35558   }
35559   jresult = (void *)result;
35560   return jresult;
35561 }
35562
35563
35564 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGesture__SWIG_2(void * jarg1) {
35565   void * jresult ;
35566   Dali::PanGesture *arg1 = 0 ;
35567   Dali::PanGesture *result = 0 ;
35568
35569   arg1 = (Dali::PanGesture *)jarg1;
35570   if (!arg1) {
35571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35572     return 0;
35573   }
35574   {
35575     try {
35576       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35577     } catch (std::out_of_range& e) {
35578       {
35579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35580       };
35581     } catch (std::exception& e) {
35582       {
35583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35584       };
35585     } catch (...) {
35586       {
35587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35588       };
35589     }
35590   }
35591   jresult = (void *)result;
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_Assign(void * jarg1, void * jarg2) {
35597   void * jresult ;
35598   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35599   Dali::PanGesture *arg2 = 0 ;
35600   Dali::PanGesture *result = 0 ;
35601
35602   arg1 = (Dali::PanGesture *)jarg1;
35603   arg2 = (Dali::PanGesture *)jarg2;
35604   if (!arg2) {
35605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35606     return 0;
35607   }
35608   {
35609     try {
35610       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35611     } catch (std::out_of_range& e) {
35612       {
35613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35614       };
35615     } catch (std::exception& e) {
35616       {
35617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35618       };
35619     } catch (...) {
35620       {
35621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35622       };
35623     }
35624   }
35625   jresult = (void *)result;
35626   return jresult;
35627 }
35628
35629
35630 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGesture(void * jarg1) {
35631   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35632
35633   arg1 = (Dali::PanGesture *)jarg1;
35634   {
35635     try {
35636       delete arg1;
35637     } catch (std::out_of_range& e) {
35638       {
35639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35640       };
35641     } catch (std::exception& e) {
35642       {
35643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35644       };
35645     } catch (...) {
35646       {
35647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35648       };
35649     }
35650   }
35651 }
35652
35653
35654 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35656   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35657
35658   arg1 = (Dali::PanGesture *)jarg1;
35659   arg2 = (Dali::Vector2 *)jarg2;
35660   if (arg1) (arg1)->velocity = *arg2;
35661 }
35662
35663
35664 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_velocity_get(void * jarg1) {
35665   void * jresult ;
35666   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35667   Dali::Vector2 *result = 0 ;
35668
35669   arg1 = (Dali::PanGesture *)jarg1;
35670   result = (Dali::Vector2 *)& ((arg1)->velocity);
35671   jresult = (void *)result;
35672   return jresult;
35673 }
35674
35675
35676 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_displacement_set(void * jarg1, void * jarg2) {
35677   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35678   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35679
35680   arg1 = (Dali::PanGesture *)jarg1;
35681   arg2 = (Dali::Vector2 *)jarg2;
35682   if (arg1) (arg1)->displacement = *arg2;
35683 }
35684
35685
35686 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_displacement_get(void * jarg1) {
35687   void * jresult ;
35688   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35689   Dali::Vector2 *result = 0 ;
35690
35691   arg1 = (Dali::PanGesture *)jarg1;
35692   result = (Dali::Vector2 *)& ((arg1)->displacement);
35693   jresult = (void *)result;
35694   return jresult;
35695 }
35696
35697
35698 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_position_set(void * jarg1, void * jarg2) {
35699   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35700   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35701
35702   arg1 = (Dali::PanGesture *)jarg1;
35703   arg2 = (Dali::Vector2 *)jarg2;
35704   if (arg1) (arg1)->position = *arg2;
35705 }
35706
35707
35708 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_position_get(void * jarg1) {
35709   void * jresult ;
35710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35711   Dali::Vector2 *result = 0 ;
35712
35713   arg1 = (Dali::PanGesture *)jarg1;
35714   result = (Dali::Vector2 *)& ((arg1)->position);
35715   jresult = (void *)result;
35716   return jresult;
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
35721   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35722   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35723
35724   arg1 = (Dali::PanGesture *)jarg1;
35725   arg2 = (Dali::Vector2 *)jarg2;
35726   if (arg1) (arg1)->screenVelocity = *arg2;
35727 }
35728
35729
35730 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenVelocity_get(void * jarg1) {
35731   void * jresult ;
35732   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35733   Dali::Vector2 *result = 0 ;
35734
35735   arg1 = (Dali::PanGesture *)jarg1;
35736   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
35737   jresult = (void *)result;
35738   return jresult;
35739 }
35740
35741
35742 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
35743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35744   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35745
35746   arg1 = (Dali::PanGesture *)jarg1;
35747   arg2 = (Dali::Vector2 *)jarg2;
35748   if (arg1) (arg1)->screenDisplacement = *arg2;
35749 }
35750
35751
35752 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenDisplacement_get(void * jarg1) {
35753   void * jresult ;
35754   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35755   Dali::Vector2 *result = 0 ;
35756
35757   arg1 = (Dali::PanGesture *)jarg1;
35758   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
35759   jresult = (void *)result;
35760   return jresult;
35761 }
35762
35763
35764 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
35765   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35766   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35767
35768   arg1 = (Dali::PanGesture *)jarg1;
35769   arg2 = (Dali::Vector2 *)jarg2;
35770   if (arg1) (arg1)->screenPosition = *arg2;
35771 }
35772
35773
35774 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PanGesture_screenPosition_get(void * jarg1) {
35775   void * jresult ;
35776   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35777   Dali::Vector2 *result = 0 ;
35778
35779   arg1 = (Dali::PanGesture *)jarg1;
35780   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
35781   jresult = (void *)result;
35782   return jresult;
35783 }
35784
35785
35786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
35787   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35788   unsigned int arg2 ;
35789
35790   arg1 = (Dali::PanGesture *)jarg1;
35791   arg2 = (unsigned int)jarg2;
35792   if (arg1) (arg1)->numberOfTouches = arg2;
35793 }
35794
35795
35796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGesture_numberOfTouches_get(void * jarg1) {
35797   unsigned int jresult ;
35798   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35799   unsigned int result;
35800
35801   arg1 = (Dali::PanGesture *)jarg1;
35802   result = (unsigned int) ((arg1)->numberOfTouches);
35803   jresult = result;
35804   return jresult;
35805 }
35806
35807
35808 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetSpeed(void * jarg1) {
35809   float jresult ;
35810   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35811   float result;
35812
35813   arg1 = (Dali::PanGesture *)jarg1;
35814   {
35815     try {
35816       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
35817     } catch (std::out_of_range& e) {
35818       {
35819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35820       };
35821     } catch (std::exception& e) {
35822       {
35823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (...) {
35826       {
35827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35828       };
35829     }
35830   }
35831   jresult = result;
35832   return jresult;
35833 }
35834
35835
35836 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetDistance(void * jarg1) {
35837   float jresult ;
35838   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35839   float result;
35840
35841   arg1 = (Dali::PanGesture *)jarg1;
35842   {
35843     try {
35844       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
35845     } catch (std::out_of_range& e) {
35846       {
35847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35848       };
35849     } catch (std::exception& e) {
35850       {
35851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35852       };
35853     } catch (...) {
35854       {
35855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35856       };
35857     }
35858   }
35859   jresult = result;
35860   return jresult;
35861 }
35862
35863
35864 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetScreenSpeed(void * jarg1) {
35865   float jresult ;
35866   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35867   float result;
35868
35869   arg1 = (Dali::PanGesture *)jarg1;
35870   {
35871     try {
35872       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
35873     } catch (std::out_of_range& e) {
35874       {
35875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35876       };
35877     } catch (std::exception& e) {
35878       {
35879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35880       };
35881     } catch (...) {
35882       {
35883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35884       };
35885     }
35886   }
35887   jresult = result;
35888   return jresult;
35889 }
35890
35891
35892 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PanGesture_GetScreenDistance(void * jarg1) {
35893   float jresult ;
35894   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35895   float result;
35896
35897   arg1 = (Dali::PanGesture *)jarg1;
35898   {
35899     try {
35900       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
35901     } catch (std::out_of_range& e) {
35902       {
35903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35904       };
35905     } catch (std::exception& e) {
35906       {
35907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35912       };
35913     }
35914   }
35915   jresult = result;
35916   return jresult;
35917 }
35918
35919
35920 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetector__SWIG_0() {
35921   void * jresult ;
35922   Dali::PinchGestureDetector *result = 0 ;
35923
35924   {
35925     try {
35926       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
35927     } catch (std::out_of_range& e) {
35928       {
35929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35930       };
35931     } catch (std::exception& e) {
35932       {
35933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35934       };
35935     } catch (...) {
35936       {
35937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35938       };
35939     }
35940   }
35941   jresult = (void *)result;
35942   return jresult;
35943 }
35944
35945
35946 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_New() {
35947   void * jresult ;
35948   Dali::PinchGestureDetector result;
35949
35950   {
35951     try {
35952       result = Dali::PinchGestureDetector::New();
35953     } catch (std::out_of_range& e) {
35954       {
35955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (std::exception& e) {
35958       {
35959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (...) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35964       };
35965     }
35966   }
35967   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_DownCast(void * jarg1) {
35973   void * jresult ;
35974   Dali::BaseHandle arg1 ;
35975   Dali::BaseHandle *argp1 ;
35976   Dali::PinchGestureDetector result;
35977
35978   argp1 = (Dali::BaseHandle *)jarg1;
35979   if (!argp1) {
35980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35981     return 0;
35982   }
35983   arg1 = *argp1;
35984   {
35985     try {
35986       result = Dali::PinchGestureDetector::DownCast(arg1);
35987     } catch (std::out_of_range& e) {
35988       {
35989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35990       };
35991     } catch (std::exception& e) {
35992       {
35993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (...) {
35996       {
35997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35998       };
35999     }
36000   }
36001   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36002   return jresult;
36003 }
36004
36005
36006 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGestureDetector(void * jarg1) {
36007   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36008
36009   arg1 = (Dali::PinchGestureDetector *)jarg1;
36010   {
36011     try {
36012       delete arg1;
36013     } catch (std::out_of_range& e) {
36014       {
36015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36016       };
36017     } catch (std::exception& e) {
36018       {
36019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36020       };
36021     } catch (...) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36024       };
36025     }
36026   }
36027 }
36028
36029
36030 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36031   void * jresult ;
36032   Dali::PinchGestureDetector *arg1 = 0 ;
36033   Dali::PinchGestureDetector *result = 0 ;
36034
36035   arg1 = (Dali::PinchGestureDetector *)jarg1;
36036   if (!arg1) {
36037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36038     return 0;
36039   }
36040   {
36041     try {
36042       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36043     } catch (std::out_of_range& e) {
36044       {
36045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36046       };
36047     } catch (std::exception& e) {
36048       {
36049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36050       };
36051     } catch (...) {
36052       {
36053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36054       };
36055     }
36056   }
36057   jresult = (void *)result;
36058   return jresult;
36059 }
36060
36061
36062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36063   void * jresult ;
36064   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36065   Dali::PinchGestureDetector *arg2 = 0 ;
36066   Dali::PinchGestureDetector *result = 0 ;
36067
36068   arg1 = (Dali::PinchGestureDetector *)jarg1;
36069   arg2 = (Dali::PinchGestureDetector *)jarg2;
36070   if (!arg2) {
36071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36072     return 0;
36073   }
36074   {
36075     try {
36076       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36077     } catch (std::out_of_range& e) {
36078       {
36079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36080       };
36081     } catch (std::exception& e) {
36082       {
36083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36084       };
36085     } catch (...) {
36086       {
36087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36088       };
36089     }
36090   }
36091   jresult = (void *)result;
36092   return jresult;
36093 }
36094
36095
36096 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_DetectedSignal(void * jarg1) {
36097   void * jresult ;
36098   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36099   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36100
36101   arg1 = (Dali::PinchGestureDetector *)jarg1;
36102   {
36103     try {
36104       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36105     } catch (std::out_of_range& e) {
36106       {
36107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36108       };
36109     } catch (std::exception& e) {
36110       {
36111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36112       };
36113     } catch (...) {
36114       {
36115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36116       };
36117     }
36118   }
36119   jresult = (void *)result;
36120   return jresult;
36121 }
36122
36123
36124 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGesture__SWIG_0(int jarg1) {
36125   void * jresult ;
36126   Dali::Gesture::State arg1 ;
36127   Dali::PinchGesture *result = 0 ;
36128
36129   arg1 = (Dali::Gesture::State)jarg1;
36130   {
36131     try {
36132       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36133     } catch (std::out_of_range& e) {
36134       {
36135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36136       };
36137     } catch (std::exception& e) {
36138       {
36139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36140       };
36141     } catch (...) {
36142       {
36143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36144       };
36145     }
36146   }
36147   jresult = (void *)result;
36148   return jresult;
36149 }
36150
36151
36152 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGesture__SWIG_1(void * jarg1) {
36153   void * jresult ;
36154   Dali::PinchGesture *arg1 = 0 ;
36155   Dali::PinchGesture *result = 0 ;
36156
36157   arg1 = (Dali::PinchGesture *)jarg1;
36158   if (!arg1) {
36159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36160     return 0;
36161   }
36162   {
36163     try {
36164       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36165     } catch (std::out_of_range& e) {
36166       {
36167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36168       };
36169     } catch (std::exception& e) {
36170       {
36171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36172       };
36173     } catch (...) {
36174       {
36175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36176       };
36177     }
36178   }
36179   jresult = (void *)result;
36180   return jresult;
36181 }
36182
36183
36184 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_Assign(void * jarg1, void * jarg2) {
36185   void * jresult ;
36186   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36187   Dali::PinchGesture *arg2 = 0 ;
36188   Dali::PinchGesture *result = 0 ;
36189
36190   arg1 = (Dali::PinchGesture *)jarg1;
36191   arg2 = (Dali::PinchGesture *)jarg2;
36192   if (!arg2) {
36193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36194     return 0;
36195   }
36196   {
36197     try {
36198       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36199     } catch (std::out_of_range& e) {
36200       {
36201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36202       };
36203     } catch (std::exception& e) {
36204       {
36205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36206       };
36207     } catch (...) {
36208       {
36209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36210       };
36211     }
36212   }
36213   jresult = (void *)result;
36214   return jresult;
36215 }
36216
36217
36218 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGesture(void * jarg1) {
36219   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36220
36221   arg1 = (Dali::PinchGesture *)jarg1;
36222   {
36223     try {
36224       delete arg1;
36225     } catch (std::out_of_range& e) {
36226       {
36227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36228       };
36229     } catch (std::exception& e) {
36230       {
36231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36232       };
36233     } catch (...) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36236       };
36237     }
36238   }
36239 }
36240
36241
36242 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_scale_set(void * jarg1, float jarg2) {
36243   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36244   float arg2 ;
36245
36246   arg1 = (Dali::PinchGesture *)jarg1;
36247   arg2 = (float)jarg2;
36248   if (arg1) (arg1)->scale = arg2;
36249 }
36250
36251
36252 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PinchGesture_scale_get(void * jarg1) {
36253   float jresult ;
36254   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36255   float result;
36256
36257   arg1 = (Dali::PinchGesture *)jarg1;
36258   result = (float) ((arg1)->scale);
36259   jresult = result;
36260   return jresult;
36261 }
36262
36263
36264 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_speed_set(void * jarg1, float jarg2) {
36265   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36266   float arg2 ;
36267
36268   arg1 = (Dali::PinchGesture *)jarg1;
36269   arg2 = (float)jarg2;
36270   if (arg1) (arg1)->speed = arg2;
36271 }
36272
36273
36274 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_PinchGesture_speed_get(void * jarg1) {
36275   float jresult ;
36276   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36277   float result;
36278
36279   arg1 = (Dali::PinchGesture *)jarg1;
36280   result = (float) ((arg1)->speed);
36281   jresult = result;
36282   return jresult;
36283 }
36284
36285
36286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36287   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36288   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36289
36290   arg1 = (Dali::PinchGesture *)jarg1;
36291   arg2 = (Dali::Vector2 *)jarg2;
36292   if (arg1) (arg1)->screenCenterPoint = *arg2;
36293 }
36294
36295
36296 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_screenCenterPoint_get(void * jarg1) {
36297   void * jresult ;
36298   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36299   Dali::Vector2 *result = 0 ;
36300
36301   arg1 = (Dali::PinchGesture *)jarg1;
36302   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36303   jresult = (void *)result;
36304   return jresult;
36305 }
36306
36307
36308 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36309   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36310   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36311
36312   arg1 = (Dali::PinchGesture *)jarg1;
36313   arg2 = (Dali::Vector2 *)jarg2;
36314   if (arg1) (arg1)->localCenterPoint = *arg2;
36315 }
36316
36317
36318 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PinchGesture_localCenterPoint_get(void * jarg1) {
36319   void * jresult ;
36320   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36321   Dali::Vector2 *result = 0 ;
36322
36323   arg1 = (Dali::PinchGesture *)jarg1;
36324   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36325   jresult = (void *)result;
36326   return jresult;
36327 }
36328
36329
36330 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetector__SWIG_0() {
36331   void * jresult ;
36332   Dali::TapGestureDetector *result = 0 ;
36333
36334   {
36335     try {
36336       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36337     } catch (std::out_of_range& e) {
36338       {
36339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36340       };
36341     } catch (std::exception& e) {
36342       {
36343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36344       };
36345     } catch (...) {
36346       {
36347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36348       };
36349     }
36350   }
36351   jresult = (void *)result;
36352   return jresult;
36353 }
36354
36355
36356 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_New__SWIG_0() {
36357   void * jresult ;
36358   Dali::TapGestureDetector result;
36359
36360   {
36361     try {
36362       result = Dali::TapGestureDetector::New();
36363     } catch (std::out_of_range& e) {
36364       {
36365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36366       };
36367     } catch (std::exception& e) {
36368       {
36369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36370       };
36371     } catch (...) {
36372       {
36373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36374       };
36375     }
36376   }
36377   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36378   return jresult;
36379 }
36380
36381
36382 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36383   void * jresult ;
36384   unsigned int arg1 ;
36385   Dali::TapGestureDetector result;
36386
36387   arg1 = (unsigned int)jarg1;
36388   {
36389     try {
36390       result = Dali::TapGestureDetector::New(arg1);
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_DownCast(void * jarg1) {
36411   void * jresult ;
36412   Dali::BaseHandle arg1 ;
36413   Dali::BaseHandle *argp1 ;
36414   Dali::TapGestureDetector result;
36415
36416   argp1 = (Dali::BaseHandle *)jarg1;
36417   if (!argp1) {
36418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36419     return 0;
36420   }
36421   arg1 = *argp1;
36422   {
36423     try {
36424       result = Dali::TapGestureDetector::DownCast(arg1);
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36440   return jresult;
36441 }
36442
36443
36444 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGestureDetector(void * jarg1) {
36445   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36446
36447   arg1 = (Dali::TapGestureDetector *)jarg1;
36448   {
36449     try {
36450       delete arg1;
36451     } catch (std::out_of_range& e) {
36452       {
36453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36454       };
36455     } catch (std::exception& e) {
36456       {
36457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36458       };
36459     } catch (...) {
36460       {
36461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36462       };
36463     }
36464   }
36465 }
36466
36467
36468 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetector__SWIG_1(void * jarg1) {
36469   void * jresult ;
36470   Dali::TapGestureDetector *arg1 = 0 ;
36471   Dali::TapGestureDetector *result = 0 ;
36472
36473   arg1 = (Dali::TapGestureDetector *)jarg1;
36474   if (!arg1) {
36475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36476     return 0;
36477   }
36478   {
36479     try {
36480       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36481     } catch (std::out_of_range& e) {
36482       {
36483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36484       };
36485     } catch (std::exception& e) {
36486       {
36487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (...) {
36490       {
36491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36492       };
36493     }
36494   }
36495   jresult = (void *)result;
36496   return jresult;
36497 }
36498
36499
36500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36501   void * jresult ;
36502   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36503   Dali::TapGestureDetector *arg2 = 0 ;
36504   Dali::TapGestureDetector *result = 0 ;
36505
36506   arg1 = (Dali::TapGestureDetector *)jarg1;
36507   arg2 = (Dali::TapGestureDetector *)jarg2;
36508   if (!arg2) {
36509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36510     return 0;
36511   }
36512   {
36513     try {
36514       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36515     } catch (std::out_of_range& e) {
36516       {
36517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36518       };
36519     } catch (std::exception& e) {
36520       {
36521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36522       };
36523     } catch (...) {
36524       {
36525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36526       };
36527     }
36528   }
36529   jresult = (void *)result;
36530   return jresult;
36531 }
36532
36533
36534 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36535   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36536   unsigned int arg2 ;
36537
36538   arg1 = (Dali::TapGestureDetector *)jarg1;
36539   arg2 = (unsigned int)jarg2;
36540   {
36541     try {
36542       (arg1)->SetMinimumTapsRequired(arg2);
36543     } catch (std::out_of_range& e) {
36544       {
36545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36546       };
36547     } catch (std::exception& e) {
36548       {
36549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36550       };
36551     } catch (...) {
36552       {
36553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36554       };
36555     }
36556   }
36557 }
36558
36559
36560 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36561   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36562   unsigned int arg2 ;
36563
36564   arg1 = (Dali::TapGestureDetector *)jarg1;
36565   arg2 = (unsigned int)jarg2;
36566   {
36567     try {
36568       (arg1)->SetMaximumTapsRequired(arg2);
36569     } catch (std::out_of_range& e) {
36570       {
36571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36572       };
36573     } catch (std::exception& e) {
36574       {
36575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36576       };
36577     } catch (...) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36580       };
36581     }
36582   }
36583 }
36584
36585
36586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36587   unsigned int jresult ;
36588   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36589   unsigned int result;
36590
36591   arg1 = (Dali::TapGestureDetector *)jarg1;
36592   {
36593     try {
36594       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36595     } catch (std::out_of_range& e) {
36596       {
36597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36598       };
36599     } catch (std::exception& e) {
36600       {
36601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36602       };
36603     } catch (...) {
36604       {
36605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36606       };
36607     }
36608   }
36609   jresult = result;
36610   return jresult;
36611 }
36612
36613
36614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36615   unsigned int jresult ;
36616   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36617   unsigned int result;
36618
36619   arg1 = (Dali::TapGestureDetector *)jarg1;
36620   {
36621     try {
36622       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36623     } catch (std::out_of_range& e) {
36624       {
36625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36626       };
36627     } catch (std::exception& e) {
36628       {
36629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36630       };
36631     } catch (...) {
36632       {
36633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36634       };
36635     }
36636   }
36637   jresult = result;
36638   return jresult;
36639 }
36640
36641
36642 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGestureDetector_DetectedSignal(void * jarg1) {
36643   void * jresult ;
36644   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36645   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36646
36647   arg1 = (Dali::TapGestureDetector *)jarg1;
36648   {
36649     try {
36650       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36651     } catch (std::out_of_range& e) {
36652       {
36653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36654       };
36655     } catch (std::exception& e) {
36656       {
36657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36658       };
36659     } catch (...) {
36660       {
36661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36662       };
36663     }
36664   }
36665   jresult = (void *)result;
36666   return jresult;
36667 }
36668
36669
36670 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGesture__SWIG_0() {
36671   void * jresult ;
36672   Dali::TapGesture *result = 0 ;
36673
36674   {
36675     try {
36676       result = (Dali::TapGesture *)new Dali::TapGesture();
36677     } catch (std::out_of_range& e) {
36678       {
36679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36680       };
36681     } catch (std::exception& e) {
36682       {
36683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36684       };
36685     } catch (...) {
36686       {
36687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36688       };
36689     }
36690   }
36691   jresult = (void *)result;
36692   return jresult;
36693 }
36694
36695
36696 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGesture__SWIG_1(void * jarg1) {
36697   void * jresult ;
36698   Dali::TapGesture *arg1 = 0 ;
36699   Dali::TapGesture *result = 0 ;
36700
36701   arg1 = (Dali::TapGesture *)jarg1;
36702   if (!arg1) {
36703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36704     return 0;
36705   }
36706   {
36707     try {
36708       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
36709     } catch (std::out_of_range& e) {
36710       {
36711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (std::exception& e) {
36714       {
36715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36716       };
36717     } catch (...) {
36718       {
36719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36720       };
36721     }
36722   }
36723   jresult = (void *)result;
36724   return jresult;
36725 }
36726
36727
36728 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_Assign(void * jarg1, void * jarg2) {
36729   void * jresult ;
36730   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36731   Dali::TapGesture *arg2 = 0 ;
36732   Dali::TapGesture *result = 0 ;
36733
36734   arg1 = (Dali::TapGesture *)jarg1;
36735   arg2 = (Dali::TapGesture *)jarg2;
36736   if (!arg2) {
36737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36738     return 0;
36739   }
36740   {
36741     try {
36742       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
36743     } catch (std::out_of_range& e) {
36744       {
36745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36746       };
36747     } catch (std::exception& e) {
36748       {
36749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36750       };
36751     } catch (...) {
36752       {
36753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36754       };
36755     }
36756   }
36757   jresult = (void *)result;
36758   return jresult;
36759 }
36760
36761
36762 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGesture(void * jarg1) {
36763   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36764
36765   arg1 = (Dali::TapGesture *)jarg1;
36766   {
36767     try {
36768       delete arg1;
36769     } catch (std::out_of_range& e) {
36770       {
36771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36772       };
36773     } catch (std::exception& e) {
36774       {
36775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36776       };
36777     } catch (...) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36780       };
36781     }
36782   }
36783 }
36784
36785
36786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
36787   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36788   unsigned int arg2 ;
36789
36790   arg1 = (Dali::TapGesture *)jarg1;
36791   arg2 = (unsigned int)jarg2;
36792   if (arg1) (arg1)->numberOfTaps = arg2;
36793 }
36794
36795
36796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTaps_get(void * jarg1) {
36797   unsigned int jresult ;
36798   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36799   unsigned int result;
36800
36801   arg1 = (Dali::TapGesture *)jarg1;
36802   result = (unsigned int) ((arg1)->numberOfTaps);
36803   jresult = result;
36804   return jresult;
36805 }
36806
36807
36808 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36810   unsigned int arg2 ;
36811
36812   arg1 = (Dali::TapGesture *)jarg1;
36813   arg2 = (unsigned int)jarg2;
36814   if (arg1) (arg1)->numberOfTouches = arg2;
36815 }
36816
36817
36818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGesture_numberOfTouches_get(void * jarg1) {
36819   unsigned int jresult ;
36820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36821   unsigned int result;
36822
36823   arg1 = (Dali::TapGesture *)jarg1;
36824   result = (unsigned int) ((arg1)->numberOfTouches);
36825   jresult = result;
36826   return jresult;
36827 }
36828
36829
36830 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
36831   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36832   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36833
36834   arg1 = (Dali::TapGesture *)jarg1;
36835   arg2 = (Dali::Vector2 *)jarg2;
36836   if (arg1) (arg1)->screenPoint = *arg2;
36837 }
36838
36839
36840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_screenPoint_get(void * jarg1) {
36841   void * jresult ;
36842   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36843   Dali::Vector2 *result = 0 ;
36844
36845   arg1 = (Dali::TapGesture *)jarg1;
36846   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
36847   jresult = (void *)result;
36848   return jresult;
36849 }
36850
36851
36852 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
36853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36854   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36855
36856   arg1 = (Dali::TapGesture *)jarg1;
36857   arg2 = (Dali::Vector2 *)jarg2;
36858   if (arg1) (arg1)->localPoint = *arg2;
36859 }
36860
36861
36862 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TapGesture_localPoint_get(void * jarg1) {
36863   void * jresult ;
36864   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36865   Dali::Vector2 *result = 0 ;
36866
36867   arg1 = (Dali::TapGesture *)jarg1;
36868   result = (Dali::Vector2 *)& ((arg1)->localPoint);
36869   jresult = (void *)result;
36870   return jresult;
36871 }
36872
36873
36874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchEvent__SWIG_0() {
36875   void * jresult ;
36876   Dali::TouchEvent *result = 0 ;
36877
36878   {
36879     try {
36880       result = (Dali::TouchEvent *)new Dali::TouchEvent();
36881     } catch (std::out_of_range& e) {
36882       {
36883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (std::exception& e) {
36886       {
36887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36892       };
36893     }
36894   }
36895   jresult = (void *)result;
36896   return jresult;
36897 }
36898
36899
36900 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchEvent__SWIG_1(unsigned long jarg1) {
36901   void * jresult ;
36902   unsigned long arg1 ;
36903   Dali::TouchEvent *result = 0 ;
36904
36905   arg1 = (unsigned long)jarg1;
36906   {
36907     try {
36908       result = (Dali::TouchEvent *)new Dali::TouchEvent(arg1);
36909     } catch (std::out_of_range& e) {
36910       {
36911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (std::exception& e) {
36914       {
36915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36920       };
36921     }
36922   }
36923   jresult = (void *)result;
36924   return jresult;
36925 }
36926
36927
36928 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchEvent(void * jarg1) {
36929   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36930
36931   arg1 = (Dali::TouchEvent *)jarg1;
36932   {
36933     try {
36934       delete arg1;
36935     } catch (std::out_of_range& e) {
36936       {
36937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36938       };
36939     } catch (std::exception& e) {
36940       {
36941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36942       };
36943     } catch (...) {
36944       {
36945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36946       };
36947     }
36948   }
36949 }
36950
36951
36952 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchEvent_points_set(void * jarg1, void * jarg2) {
36953   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36954   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
36955
36956   arg1 = (Dali::TouchEvent *)jarg1;
36957   arg2 = (Dali::TouchPointContainer *)jarg2;
36958   if (arg1) (arg1)->points = *arg2;
36959 }
36960
36961
36962 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchEvent_points_get(void * jarg1) {
36963   void * jresult ;
36964   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36965   Dali::TouchPointContainer *result = 0 ;
36966
36967   arg1 = (Dali::TouchEvent *)jarg1;
36968   result = (Dali::TouchPointContainer *)& ((arg1)->points);
36969   jresult = (void *)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchEvent_time_set(void * jarg1, unsigned long jarg2) {
36975   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36976   unsigned long arg2 ;
36977
36978   arg1 = (Dali::TouchEvent *)jarg1;
36979   arg2 = (unsigned long)jarg2;
36980   if (arg1) (arg1)->time = arg2;
36981 }
36982
36983
36984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchEvent_time_get(void * jarg1) {
36985   unsigned long jresult ;
36986   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36987   unsigned long result;
36988
36989   arg1 = (Dali::TouchEvent *)jarg1;
36990   result = (unsigned long) ((arg1)->time);
36991   jresult = (unsigned long)result;
36992   return jresult;
36993 }
36994
36995
36996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TouchEvent_GetPointCount(void * jarg1) {
36997   unsigned int jresult ;
36998   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
36999   unsigned int result;
37000
37001   arg1 = (Dali::TouchEvent *)jarg1;
37002   {
37003     try {
37004       result = (unsigned int)((Dali::TouchEvent const *)arg1)->GetPointCount();
37005     } catch (std::out_of_range& e) {
37006       {
37007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37008       };
37009     } catch (std::exception& e) {
37010       {
37011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37012       };
37013     } catch (...) {
37014       {
37015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37016       };
37017     }
37018   }
37019   jresult = result;
37020   return jresult;
37021 }
37022
37023
37024 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchEvent_GetPoint(void * jarg1, unsigned int jarg2) {
37025   void * jresult ;
37026   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
37027   unsigned int arg2 ;
37028   Dali::TouchPoint *result = 0 ;
37029
37030   arg1 = (Dali::TouchEvent *)jarg1;
37031   arg2 = (unsigned int)jarg2;
37032   {
37033     try {
37034       result = (Dali::TouchPoint *) &((Dali::TouchEvent const *)arg1)->GetPoint(arg2);
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (...) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37046       };
37047     }
37048   }
37049   jresult = (void *)result;
37050   return jresult;
37051 }
37052
37053
37054 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_0() {
37055   void * jresult ;
37056   Dali::AlphaFunction *result = 0 ;
37057
37058   {
37059     try {
37060       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37061     } catch (std::out_of_range& e) {
37062       {
37063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37064       };
37065     } catch (std::exception& e) {
37066       {
37067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (...) {
37070       {
37071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37072       };
37073     }
37074   }
37075   jresult = (void *)result;
37076   return jresult;
37077 }
37078
37079
37080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_1(int jarg1) {
37081   void * jresult ;
37082   Dali::AlphaFunction::BuiltinFunction arg1 ;
37083   Dali::AlphaFunction *result = 0 ;
37084
37085   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37086   {
37087     try {
37088       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37089     } catch (std::out_of_range& e) {
37090       {
37091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (std::exception& e) {
37094       {
37095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37096       };
37097     } catch (...) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37100       };
37101     }
37102   }
37103   jresult = (void *)result;
37104   return jresult;
37105 }
37106
37107
37108 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_2(void * jarg1) {
37109   void * jresult ;
37110   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37111   Dali::AlphaFunction *result = 0 ;
37112
37113   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37114   {
37115     try {
37116       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37117     } catch (std::out_of_range& e) {
37118       {
37119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37120       };
37121     } catch (std::exception& e) {
37122       {
37123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37124       };
37125     } catch (...) {
37126       {
37127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37128       };
37129     }
37130   }
37131   jresult = (void *)result;
37132   return jresult;
37133 }
37134
37135
37136 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37137   void * jresult ;
37138   Dali::Vector2 *arg1 = 0 ;
37139   Dali::Vector2 *arg2 = 0 ;
37140   Dali::AlphaFunction *result = 0 ;
37141
37142   arg1 = (Dali::Vector2 *)jarg1;
37143   if (!arg1) {
37144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37145     return 0;
37146   }
37147   arg2 = (Dali::Vector2 *)jarg2;
37148   if (!arg2) {
37149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37150     return 0;
37151   }
37152   {
37153     try {
37154       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37155     } catch (std::out_of_range& e) {
37156       {
37157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37158       };
37159     } catch (std::exception& e) {
37160       {
37161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37162       };
37163     } catch (...) {
37164       {
37165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37166       };
37167     }
37168   }
37169   jresult = (void *)result;
37170   return jresult;
37171 }
37172
37173
37174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37175   void * jresult ;
37176   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37177   Dali::Vector4 result;
37178
37179   arg1 = (Dali::AlphaFunction *)jarg1;
37180   {
37181     try {
37182       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37183     } catch (std::out_of_range& e) {
37184       {
37185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37186       };
37187     } catch (std::exception& e) {
37188       {
37189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37190       };
37191     } catch (...) {
37192       {
37193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37194       };
37195     }
37196   }
37197   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37198   return jresult;
37199 }
37200
37201
37202 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AlphaFunction_GetCustomFunction(void * jarg1) {
37203   void * jresult ;
37204   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37205   Dali::AlphaFunctionPrototype result;
37206
37207   arg1 = (Dali::AlphaFunction *)jarg1;
37208   {
37209     try {
37210       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37211     } catch (std::out_of_range& e) {
37212       {
37213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37214       };
37215     } catch (std::exception& e) {
37216       {
37217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37218       };
37219     } catch (...) {
37220       {
37221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37222       };
37223     }
37224   }
37225   jresult = (void *)result;
37226   return jresult;
37227 }
37228
37229
37230 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37231   int jresult ;
37232   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37233   Dali::AlphaFunction::BuiltinFunction result;
37234
37235   arg1 = (Dali::AlphaFunction *)jarg1;
37236   {
37237     try {
37238       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37239     } catch (std::out_of_range& e) {
37240       {
37241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37242       };
37243     } catch (std::exception& e) {
37244       {
37245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37246       };
37247     } catch (...) {
37248       {
37249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37250       };
37251     }
37252   }
37253   jresult = (int)result;
37254   return jresult;
37255 }
37256
37257
37258 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_AlphaFunction_GetMode(void * jarg1) {
37259   int jresult ;
37260   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37261   Dali::AlphaFunction::Mode result;
37262
37263   arg1 = (Dali::AlphaFunction *)jarg1;
37264   {
37265     try {
37266       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37267     } catch (std::out_of_range& e) {
37268       {
37269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37270       };
37271     } catch (std::exception& e) {
37272       {
37273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37274       };
37275     } catch (...) {
37276       {
37277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37278       };
37279     }
37280   }
37281   jresult = (int)result;
37282   return jresult;
37283 }
37284
37285
37286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AlphaFunction(void * jarg1) {
37287   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37288
37289   arg1 = (Dali::AlphaFunction *)jarg1;
37290   {
37291     try {
37292       delete arg1;
37293     } catch (std::out_of_range& e) {
37294       {
37295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37296       };
37297     } catch (std::exception& e) {
37298       {
37299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37304       };
37305     }
37306   }
37307 }
37308
37309
37310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_New() {
37311   void * jresult ;
37312   Dali::KeyFrames result;
37313
37314   {
37315     try {
37316       result = Dali::KeyFrames::New();
37317     } catch (std::out_of_range& e) {
37318       {
37319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37320       };
37321     } catch (std::exception& e) {
37322       {
37323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37324       };
37325     } catch (...) {
37326       {
37327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37328       };
37329     }
37330   }
37331   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37332   return jresult;
37333 }
37334
37335
37336 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_DownCast(void * jarg1) {
37337   void * jresult ;
37338   Dali::BaseHandle arg1 ;
37339   Dali::BaseHandle *argp1 ;
37340   Dali::KeyFrames result;
37341
37342   argp1 = (Dali::BaseHandle *)jarg1;
37343   if (!argp1) {
37344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37345     return 0;
37346   }
37347   arg1 = *argp1;
37348   {
37349     try {
37350       result = Dali::KeyFrames::DownCast(arg1);
37351     } catch (std::out_of_range& e) {
37352       {
37353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37354       };
37355     } catch (std::exception& e) {
37356       {
37357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37358       };
37359     } catch (...) {
37360       {
37361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37362       };
37363     }
37364   }
37365   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyFrames__SWIG_0() {
37371   void * jresult ;
37372   Dali::KeyFrames *result = 0 ;
37373
37374   {
37375     try {
37376       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37377     } catch (std::out_of_range& e) {
37378       {
37379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37380       };
37381     } catch (std::exception& e) {
37382       {
37383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37384       };
37385     } catch (...) {
37386       {
37387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37388       };
37389     }
37390   }
37391   jresult = (void *)result;
37392   return jresult;
37393 }
37394
37395
37396 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyFrames(void * jarg1) {
37397   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37398
37399   arg1 = (Dali::KeyFrames *)jarg1;
37400   {
37401     try {
37402       delete arg1;
37403     } catch (std::out_of_range& e) {
37404       {
37405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37406       };
37407     } catch (std::exception& e) {
37408       {
37409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37410       };
37411     } catch (...) {
37412       {
37413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37414       };
37415     }
37416   }
37417 }
37418
37419
37420 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyFrames__SWIG_1(void * jarg1) {
37421   void * jresult ;
37422   Dali::KeyFrames *arg1 = 0 ;
37423   Dali::KeyFrames *result = 0 ;
37424
37425   arg1 = (Dali::KeyFrames *)jarg1;
37426   if (!arg1) {
37427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37428     return 0;
37429   }
37430   {
37431     try {
37432       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37433     } catch (std::out_of_range& e) {
37434       {
37435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37436       };
37437     } catch (std::exception& e) {
37438       {
37439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37440       };
37441     } catch (...) {
37442       {
37443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37444       };
37445     }
37446   }
37447   jresult = (void *)result;
37448   return jresult;
37449 }
37450
37451
37452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyFrames_Assign(void * jarg1, void * jarg2) {
37453   void * jresult ;
37454   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37455   Dali::KeyFrames *arg2 = 0 ;
37456   Dali::KeyFrames *result = 0 ;
37457
37458   arg1 = (Dali::KeyFrames *)jarg1;
37459   arg2 = (Dali::KeyFrames *)jarg2;
37460   if (!arg2) {
37461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37462     return 0;
37463   }
37464   {
37465     try {
37466       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37467     } catch (std::out_of_range& e) {
37468       {
37469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37470       };
37471     } catch (std::exception& e) {
37472       {
37473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37474       };
37475     } catch (...) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37478       };
37479     }
37480   }
37481   jresult = (void *)result;
37482   return jresult;
37483 }
37484
37485
37486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_KeyFrames_GetType(void * jarg1) {
37487   int jresult ;
37488   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37489   Dali::Property::Type result;
37490
37491   arg1 = (Dali::KeyFrames *)jarg1;
37492   {
37493     try {
37494       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37495     } catch (std::out_of_range& e) {
37496       {
37497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37498       };
37499     } catch (std::exception& e) {
37500       {
37501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37502       };
37503     } catch (...) {
37504       {
37505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37506       };
37507     }
37508   }
37509   jresult = (int)result;
37510   return jresult;
37511 }
37512
37513
37514 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37515   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37516   float arg2 ;
37517   Dali::Property::Value arg3 ;
37518   Dali::Property::Value *argp3 ;
37519
37520   arg1 = (Dali::KeyFrames *)jarg1;
37521   arg2 = (float)jarg2;
37522   argp3 = (Dali::Property::Value *)jarg3;
37523   if (!argp3) {
37524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37525     return ;
37526   }
37527   arg3 = *argp3;
37528   {
37529     try {
37530       (arg1)->Add(arg2,arg3);
37531     } catch (std::out_of_range& e) {
37532       {
37533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37534       };
37535     } catch (std::exception& e) {
37536       {
37537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37542       };
37543     }
37544   }
37545 }
37546
37547
37548 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37549   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37550   float arg2 ;
37551   Dali::Property::Value arg3 ;
37552   Dali::AlphaFunction arg4 ;
37553   Dali::Property::Value *argp3 ;
37554   Dali::AlphaFunction *argp4 ;
37555
37556   arg1 = (Dali::KeyFrames *)jarg1;
37557   arg2 = (float)jarg2;
37558   argp3 = (Dali::Property::Value *)jarg3;
37559   if (!argp3) {
37560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37561     return ;
37562   }
37563   arg3 = *argp3;
37564   argp4 = (Dali::AlphaFunction *)jarg4;
37565   if (!argp4) {
37566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37567     return ;
37568   }
37569   arg4 = *argp4;
37570   {
37571     try {
37572       (arg1)->Add(arg2,arg3,arg4);
37573     } catch (std::out_of_range& e) {
37574       {
37575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37576       };
37577     } catch (std::exception& e) {
37578       {
37579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37580       };
37581     } catch (...) {
37582       {
37583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37584       };
37585     }
37586   }
37587 }
37588
37589
37590 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Path_Property_POINTS_get() {
37591   int jresult ;
37592   int result;
37593
37594   result = (int)Dali::Path::Property::POINTS;
37595   jresult = (int)result;
37596   return jresult;
37597 }
37598
37599
37600 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Path_Property_CONTROL_POINTS_get() {
37601   int jresult ;
37602   int result;
37603
37604   result = (int)Dali::Path::Property::CONTROL_POINTS;
37605   jresult = (int)result;
37606   return jresult;
37607 }
37608
37609
37610 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path_Property() {
37611   void * jresult ;
37612   Dali::Path::Property *result = 0 ;
37613
37614   {
37615     try {
37616       result = (Dali::Path::Property *)new Dali::Path::Property();
37617     } catch (std::out_of_range& e) {
37618       {
37619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37620       };
37621     } catch (std::exception& e) {
37622       {
37623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37624       };
37625     } catch (...) {
37626       {
37627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37628       };
37629     }
37630   }
37631   jresult = (void *)result;
37632   return jresult;
37633 }
37634
37635
37636 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Path_Property(void * jarg1) {
37637   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37638
37639   arg1 = (Dali::Path::Property *)jarg1;
37640   {
37641     try {
37642       delete arg1;
37643     } catch (std::out_of_range& e) {
37644       {
37645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37646       };
37647     } catch (std::exception& e) {
37648       {
37649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37650       };
37651     } catch (...) {
37652       {
37653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37654       };
37655     }
37656   }
37657 }
37658
37659
37660 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_New() {
37661   void * jresult ;
37662   Dali::Path result;
37663
37664   {
37665     try {
37666       result = Dali::Path::New();
37667     } catch (std::out_of_range& e) {
37668       {
37669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37670       };
37671     } catch (std::exception& e) {
37672       {
37673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37674       };
37675     } catch (...) {
37676       {
37677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37678       };
37679     }
37680   }
37681   jresult = new Dali::Path((const Dali::Path &)result);
37682   return jresult;
37683 }
37684
37685
37686 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_DownCast(void * jarg1) {
37687   void * jresult ;
37688   Dali::BaseHandle arg1 ;
37689   Dali::BaseHandle *argp1 ;
37690   Dali::Path result;
37691
37692   argp1 = (Dali::BaseHandle *)jarg1;
37693   if (!argp1) {
37694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37695     return 0;
37696   }
37697   arg1 = *argp1;
37698   {
37699     try {
37700       result = Dali::Path::DownCast(arg1);
37701     } catch (std::out_of_range& e) {
37702       {
37703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37704       };
37705     } catch (std::exception& e) {
37706       {
37707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37708       };
37709     } catch (...) {
37710       {
37711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37712       };
37713     }
37714   }
37715   jresult = new Dali::Path((const Dali::Path &)result);
37716   return jresult;
37717 }
37718
37719
37720 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path__SWIG_0() {
37721   void * jresult ;
37722   Dali::Path *result = 0 ;
37723
37724   {
37725     try {
37726       result = (Dali::Path *)new Dali::Path();
37727     } catch (std::out_of_range& e) {
37728       {
37729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37730       };
37731     } catch (std::exception& e) {
37732       {
37733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37734       };
37735     } catch (...) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37738       };
37739     }
37740   }
37741   jresult = (void *)result;
37742   return jresult;
37743 }
37744
37745
37746 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Path(void * jarg1) {
37747   Dali::Path *arg1 = (Dali::Path *) 0 ;
37748
37749   arg1 = (Dali::Path *)jarg1;
37750   {
37751     try {
37752       delete arg1;
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767 }
37768
37769
37770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Path__SWIG_1(void * jarg1) {
37771   void * jresult ;
37772   Dali::Path *arg1 = 0 ;
37773   Dali::Path *result = 0 ;
37774
37775   arg1 = (Dali::Path *)jarg1;
37776   if (!arg1) {
37777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37778     return 0;
37779   }
37780   {
37781     try {
37782       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37783     } catch (std::out_of_range& e) {
37784       {
37785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37786       };
37787     } catch (std::exception& e) {
37788       {
37789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37790       };
37791     } catch (...) {
37792       {
37793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37794       };
37795     }
37796   }
37797   jresult = (void *)result;
37798   return jresult;
37799 }
37800
37801
37802 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_Assign(void * jarg1, void * jarg2) {
37803   void * jresult ;
37804   Dali::Path *arg1 = (Dali::Path *) 0 ;
37805   Dali::Path *arg2 = 0 ;
37806   Dali::Path *result = 0 ;
37807
37808   arg1 = (Dali::Path *)jarg1;
37809   arg2 = (Dali::Path *)jarg2;
37810   if (!arg2) {
37811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37812     return 0;
37813   }
37814   {
37815     try {
37816       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37817     } catch (std::out_of_range& e) {
37818       {
37819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37820       };
37821     } catch (std::exception& e) {
37822       {
37823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37824       };
37825     } catch (...) {
37826       {
37827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37828       };
37829     }
37830   }
37831   jresult = (void *)result;
37832   return jresult;
37833 }
37834
37835
37836 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_AddPoint(void * jarg1, void * jarg2) {
37837   Dali::Path *arg1 = (Dali::Path *) 0 ;
37838   Dali::Vector3 *arg2 = 0 ;
37839
37840   arg1 = (Dali::Path *)jarg1;
37841   arg2 = (Dali::Vector3 *)jarg2;
37842   if (!arg2) {
37843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37844     return ;
37845   }
37846   {
37847     try {
37848       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
37849     } catch (std::out_of_range& e) {
37850       {
37851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37852       };
37853     } catch (std::exception& e) {
37854       {
37855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37856       };
37857     } catch (...) {
37858       {
37859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37860       };
37861     }
37862   }
37863 }
37864
37865
37866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_AddControlPoint(void * jarg1, void * jarg2) {
37867   Dali::Path *arg1 = (Dali::Path *) 0 ;
37868   Dali::Vector3 *arg2 = 0 ;
37869
37870   arg1 = (Dali::Path *)jarg1;
37871   arg2 = (Dali::Vector3 *)jarg2;
37872   if (!arg2) {
37873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37874     return ;
37875   }
37876   {
37877     try {
37878       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
37879     } catch (std::out_of_range& e) {
37880       {
37881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37882       };
37883     } catch (std::exception& e) {
37884       {
37885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37886       };
37887     } catch (...) {
37888       {
37889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37890       };
37891     }
37892   }
37893 }
37894
37895
37896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_GenerateControlPoints(void * jarg1, float jarg2) {
37897   Dali::Path *arg1 = (Dali::Path *) 0 ;
37898   float arg2 ;
37899
37900   arg1 = (Dali::Path *)jarg1;
37901   arg2 = (float)jarg2;
37902   {
37903     try {
37904       (arg1)->GenerateControlPoints(arg2);
37905     } catch (std::out_of_range& e) {
37906       {
37907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37908       };
37909     } catch (std::exception& e) {
37910       {
37911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37912       };
37913     } catch (...) {
37914       {
37915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37916       };
37917     }
37918   }
37919 }
37920
37921
37922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37923   Dali::Path *arg1 = (Dali::Path *) 0 ;
37924   float arg2 ;
37925   Dali::Vector3 *arg3 = 0 ;
37926   Dali::Vector3 *arg4 = 0 ;
37927
37928   arg1 = (Dali::Path *)jarg1;
37929   arg2 = (float)jarg2;
37930   arg3 = (Dali::Vector3 *)jarg3;
37931   if (!arg3) {
37932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37933     return ;
37934   }
37935   arg4 = (Dali::Vector3 *)jarg4;
37936   if (!arg4) {
37937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37938     return ;
37939   }
37940   {
37941     try {
37942       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
37943     } catch (std::out_of_range& e) {
37944       {
37945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37946       };
37947     } catch (std::exception& e) {
37948       {
37949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37950       };
37951     } catch (...) {
37952       {
37953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37954       };
37955     }
37956   }
37957 }
37958
37959
37960 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_GetPoint(void * jarg1, unsigned long jarg2) {
37961   void * jresult ;
37962   Dali::Path *arg1 = (Dali::Path *) 0 ;
37963   size_t arg2 ;
37964   Dali::Vector3 *result = 0 ;
37965
37966   arg1 = (Dali::Path *)jarg1;
37967   arg2 = (size_t)jarg2;
37968   {
37969     try {
37970       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
37971     } catch (std::out_of_range& e) {
37972       {
37973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37974       };
37975     } catch (std::exception& e) {
37976       {
37977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37978       };
37979     } catch (...) {
37980       {
37981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37982       };
37983     }
37984   }
37985   jresult = (void *)result;
37986   return jresult;
37987 }
37988
37989
37990 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
37991   void * jresult ;
37992   Dali::Path *arg1 = (Dali::Path *) 0 ;
37993   size_t arg2 ;
37994   Dali::Vector3 *result = 0 ;
37995
37996   arg1 = (Dali::Path *)jarg1;
37997   arg2 = (size_t)jarg2;
37998   {
37999     try {
38000       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38001     } catch (std::out_of_range& e) {
38002       {
38003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38004       };
38005     } catch (std::exception& e) {
38006       {
38007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38008       };
38009     } catch (...) {
38010       {
38011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38012       };
38013     }
38014   }
38015   jresult = (void *)result;
38016   return jresult;
38017 }
38018
38019
38020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_Path_GetPointCount(void * jarg1) {
38021   unsigned long jresult ;
38022   Dali::Path *arg1 = (Dali::Path *) 0 ;
38023   size_t result;
38024
38025   arg1 = (Dali::Path *)jarg1;
38026   {
38027     try {
38028       result = ((Dali::Path const *)arg1)->GetPointCount();
38029     } catch (std::out_of_range& e) {
38030       {
38031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (std::exception& e) {
38034       {
38035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38040       };
38041     }
38042   }
38043   jresult = (unsigned long)result;
38044   return jresult;
38045 }
38046
38047
38048 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimePeriod__SWIG_0(float jarg1) {
38049   void * jresult ;
38050   float arg1 ;
38051   Dali::TimePeriod *result = 0 ;
38052
38053   arg1 = (float)jarg1;
38054   {
38055     try {
38056       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38057     } catch (std::out_of_range& e) {
38058       {
38059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38060       };
38061     } catch (std::exception& e) {
38062       {
38063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38064       };
38065     } catch (...) {
38066       {
38067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38068       };
38069     }
38070   }
38071   jresult = (void *)result;
38072   return jresult;
38073 }
38074
38075
38076 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38077   void * jresult ;
38078   float arg1 ;
38079   float arg2 ;
38080   Dali::TimePeriod *result = 0 ;
38081
38082   arg1 = (float)jarg1;
38083   arg2 = (float)jarg2;
38084   {
38085     try {
38086       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101   jresult = (void *)result;
38102   return jresult;
38103 }
38104
38105
38106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TimePeriod(void * jarg1) {
38107   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38108
38109   arg1 = (Dali::TimePeriod *)jarg1;
38110   {
38111     try {
38112       delete arg1;
38113     } catch (std::out_of_range& e) {
38114       {
38115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38116       };
38117     } catch (std::exception& e) {
38118       {
38119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38120       };
38121     } catch (...) {
38122       {
38123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38124       };
38125     }
38126   }
38127 }
38128
38129
38130 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38131   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38132   float arg2 ;
38133
38134   arg1 = (Dali::TimePeriod *)jarg1;
38135   arg2 = (float)jarg2;
38136   if (arg1) (arg1)->delaySeconds = arg2;
38137 }
38138
38139
38140 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TimePeriod_delaySeconds_get(void * jarg1) {
38141   float jresult ;
38142   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38143   float result;
38144
38145   arg1 = (Dali::TimePeriod *)jarg1;
38146   result = (float) ((arg1)->delaySeconds);
38147   jresult = result;
38148   return jresult;
38149 }
38150
38151
38152 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38153   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38154   float arg2 ;
38155
38156   arg1 = (Dali::TimePeriod *)jarg1;
38157   arg2 = (float)jarg2;
38158   if (arg1) (arg1)->durationSeconds = arg2;
38159 }
38160
38161
38162 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TimePeriod_durationSeconds_get(void * jarg1) {
38163   float jresult ;
38164   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38165   float result;
38166
38167   arg1 = (Dali::TimePeriod *)jarg1;
38168   result = (float) ((arg1)->durationSeconds);
38169   jresult = result;
38170   return jresult;
38171 }
38172
38173
38174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Animation__SWIG_0() {
38175   void * jresult ;
38176   Dali::Animation *result = 0 ;
38177
38178   {
38179     try {
38180       result = (Dali::Animation *)new Dali::Animation();
38181     } catch (std::out_of_range& e) {
38182       {
38183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (std::exception& e) {
38186       {
38187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38188       };
38189     } catch (...) {
38190       {
38191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38192       };
38193     }
38194   }
38195   jresult = (void *)result;
38196   return jresult;
38197 }
38198
38199
38200 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_New(float jarg1) {
38201   void * jresult ;
38202   float arg1 ;
38203   Dali::Animation result;
38204
38205   arg1 = (float)jarg1;
38206   {
38207     try {
38208       result = Dali::Animation::New(arg1);
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38216       };
38217     } catch (...) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38220       };
38221     }
38222   }
38223   jresult = new Dali::Animation((const Dali::Animation &)result);
38224   return jresult;
38225 }
38226
38227
38228 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_DownCast(void * jarg1) {
38229   void * jresult ;
38230   Dali::BaseHandle arg1 ;
38231   Dali::BaseHandle *argp1 ;
38232   Dali::Animation result;
38233
38234   argp1 = (Dali::BaseHandle *)jarg1;
38235   if (!argp1) {
38236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38237     return 0;
38238   }
38239   arg1 = *argp1;
38240   {
38241     try {
38242       result = Dali::Animation::DownCast(arg1);
38243     } catch (std::out_of_range& e) {
38244       {
38245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38246       };
38247     } catch (std::exception& e) {
38248       {
38249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38250       };
38251     } catch (...) {
38252       {
38253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38254       };
38255     }
38256   }
38257   jresult = new Dali::Animation((const Dali::Animation &)result);
38258   return jresult;
38259 }
38260
38261
38262 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Animation(void * jarg1) {
38263   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38264
38265   arg1 = (Dali::Animation *)jarg1;
38266   {
38267     try {
38268       delete arg1;
38269     } catch (std::out_of_range& e) {
38270       {
38271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38272       };
38273     } catch (std::exception& e) {
38274       {
38275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38276       };
38277     } catch (...) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38280       };
38281     }
38282   }
38283 }
38284
38285
38286 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Animation__SWIG_1(void * jarg1) {
38287   void * jresult ;
38288   Dali::Animation *arg1 = 0 ;
38289   Dali::Animation *result = 0 ;
38290
38291   arg1 = (Dali::Animation *)jarg1;
38292   if (!arg1) {
38293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38294     return 0;
38295   }
38296   {
38297     try {
38298       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (...) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38310       };
38311     }
38312   }
38313   jresult = (void *)result;
38314   return jresult;
38315 }
38316
38317
38318 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_Assign(void * jarg1, void * jarg2) {
38319   void * jresult ;
38320   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38321   Dali::Animation *arg2 = 0 ;
38322   Dali::Animation *result = 0 ;
38323
38324   arg1 = (Dali::Animation *)jarg1;
38325   arg2 = (Dali::Animation *)jarg2;
38326   if (!arg2) {
38327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38328     return 0;
38329   }
38330   {
38331     try {
38332       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38333     } catch (std::out_of_range& e) {
38334       {
38335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38336       };
38337     } catch (std::exception& e) {
38338       {
38339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38340       };
38341     } catch (...) {
38342       {
38343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38344       };
38345     }
38346   }
38347   jresult = (void *)result;
38348   return jresult;
38349 }
38350
38351
38352 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDuration(void * jarg1, float jarg2) {
38353   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38354   float arg2 ;
38355
38356   arg1 = (Dali::Animation *)jarg1;
38357   arg2 = (float)jarg2;
38358   {
38359     try {
38360       (arg1)->SetDuration(arg2);
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38372       };
38373     }
38374   }
38375 }
38376
38377
38378 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetDuration(void * jarg1) {
38379   float jresult ;
38380   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38381   float result;
38382
38383   arg1 = (Dali::Animation *)jarg1;
38384   {
38385     try {
38386       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38387     } catch (std::out_of_range& e) {
38388       {
38389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38390       };
38391     } catch (std::exception& e) {
38392       {
38393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38394       };
38395     } catch (...) {
38396       {
38397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38398       };
38399     }
38400   }
38401   jresult = result;
38402   return jresult;
38403 }
38404
38405
38406 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38407   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38408   bool arg2 ;
38409
38410   arg1 = (Dali::Animation *)jarg1;
38411   arg2 = jarg2 ? true : false;
38412   {
38413     try {
38414       (arg1)->SetLooping(arg2);
38415     } catch (std::out_of_range& e) {
38416       {
38417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38418       };
38419     } catch (std::exception& e) {
38420       {
38421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38422       };
38423     } catch (...) {
38424       {
38425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38426       };
38427     }
38428   }
38429 }
38430
38431
38432 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetLoopCount(void * jarg1, int jarg2) {
38433   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38434   int arg2 ;
38435
38436   arg1 = (Dali::Animation *)jarg1;
38437   arg2 = (int)jarg2;
38438   {
38439     try {
38440       (arg1)->SetLoopCount(arg2);
38441     } catch (std::out_of_range& e) {
38442       {
38443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38444       };
38445     } catch (std::exception& e) {
38446       {
38447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38448       };
38449     } catch (...) {
38450       {
38451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38452       };
38453     }
38454   }
38455 }
38456
38457
38458 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetLoopCount(void * jarg1) {
38459   int jresult ;
38460   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38461   int result;
38462
38463   arg1 = (Dali::Animation *)jarg1;
38464   {
38465     try {
38466       result = (int)(arg1)->GetLoopCount();
38467     } catch (std::out_of_range& e) {
38468       {
38469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38470       };
38471     } catch (std::exception& e) {
38472       {
38473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38474       };
38475     } catch (...) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38478       };
38479     }
38480   }
38481   jresult = result;
38482   return jresult;
38483 }
38484
38485
38486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetCurrentLoop(void * jarg1) {
38487   int jresult ;
38488   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38489   int result;
38490
38491   arg1 = (Dali::Animation *)jarg1;
38492   {
38493     try {
38494       result = (int)(arg1)->GetCurrentLoop();
38495     } catch (std::out_of_range& e) {
38496       {
38497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38498       };
38499     } catch (std::exception& e) {
38500       {
38501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38502       };
38503     } catch (...) {
38504       {
38505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38506       };
38507     }
38508   }
38509   jresult = result;
38510   return jresult;
38511 }
38512
38513
38514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Animation_IsLooping(void * jarg1) {
38515   unsigned int jresult ;
38516   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38517   bool result;
38518
38519   arg1 = (Dali::Animation *)jarg1;
38520   {
38521     try {
38522       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38523     } catch (std::out_of_range& e) {
38524       {
38525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38526       };
38527     } catch (std::exception& e) {
38528       {
38529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38530       };
38531     } catch (...) {
38532       {
38533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38534       };
38535     }
38536   }
38537   jresult = result;
38538   return jresult;
38539 }
38540
38541
38542 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetEndAction(void * jarg1, int jarg2) {
38543   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38544   Dali::Animation::EndAction arg2 ;
38545
38546   arg1 = (Dali::Animation *)jarg1;
38547   arg2 = (Dali::Animation::EndAction)jarg2;
38548   {
38549     try {
38550       (arg1)->SetEndAction(arg2);
38551     } catch (std::out_of_range& e) {
38552       {
38553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38554       };
38555     } catch (std::exception& e) {
38556       {
38557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38558       };
38559     } catch (...) {
38560       {
38561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38562       };
38563     }
38564   }
38565 }
38566
38567
38568 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetEndAction(void * jarg1) {
38569   int jresult ;
38570   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38571   Dali::Animation::EndAction result;
38572
38573   arg1 = (Dali::Animation *)jarg1;
38574   {
38575     try {
38576       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38577     } catch (std::out_of_range& e) {
38578       {
38579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38580       };
38581     } catch (std::exception& e) {
38582       {
38583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38584       };
38585     } catch (...) {
38586       {
38587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38588       };
38589     }
38590   }
38591   jresult = (int)result;
38592   return jresult;
38593 }
38594
38595
38596 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38597   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38598   Dali::Animation::EndAction arg2 ;
38599
38600   arg1 = (Dali::Animation *)jarg1;
38601   arg2 = (Dali::Animation::EndAction)jarg2;
38602   {
38603     try {
38604       (arg1)->SetDisconnectAction(arg2);
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38612       };
38613     } catch (...) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38616       };
38617     }
38618   }
38619 }
38620
38621
38622 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetDisconnectAction(void * jarg1) {
38623   int jresult ;
38624   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38625   Dali::Animation::EndAction result;
38626
38627   arg1 = (Dali::Animation *)jarg1;
38628   {
38629     try {
38630       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38631     } catch (std::out_of_range& e) {
38632       {
38633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38634       };
38635     } catch (std::exception& e) {
38636       {
38637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (...) {
38640       {
38641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38642       };
38643     }
38644   }
38645   jresult = (int)result;
38646   return jresult;
38647 }
38648
38649
38650 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38651   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38652   Dali::AlphaFunction arg2 ;
38653   Dali::AlphaFunction *argp2 ;
38654
38655   arg1 = (Dali::Animation *)jarg1;
38656   argp2 = (Dali::AlphaFunction *)jarg2;
38657   if (!argp2) {
38658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38659     return ;
38660   }
38661   arg2 = *argp2;
38662   {
38663     try {
38664       (arg1)->SetDefaultAlphaFunction(arg2);
38665     } catch (std::out_of_range& e) {
38666       {
38667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38668       };
38669     } catch (std::exception& e) {
38670       {
38671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38672       };
38673     } catch (...) {
38674       {
38675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38676       };
38677     }
38678   }
38679 }
38680
38681
38682 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_GetDefaultAlphaFunction(void * jarg1) {
38683   void * jresult ;
38684   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38685   Dali::AlphaFunction result;
38686
38687   arg1 = (Dali::Animation *)jarg1;
38688   {
38689     try {
38690       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38691     } catch (std::out_of_range& e) {
38692       {
38693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38694       };
38695     } catch (std::exception& e) {
38696       {
38697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (...) {
38700       {
38701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38702       };
38703     }
38704   }
38705   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38706   return jresult;
38707 }
38708
38709
38710 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38711   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38712   float arg2 ;
38713
38714   arg1 = (Dali::Animation *)jarg1;
38715   arg2 = (float)jarg2;
38716   {
38717     try {
38718       (arg1)->SetCurrentProgress(arg2);
38719     } catch (std::out_of_range& e) {
38720       {
38721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38722       };
38723     } catch (std::exception& e) {
38724       {
38725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38730       };
38731     }
38732   }
38733 }
38734
38735
38736 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetCurrentProgress(void * jarg1) {
38737   float jresult ;
38738   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38739   float result;
38740
38741   arg1 = (Dali::Animation *)jarg1;
38742   {
38743     try {
38744       result = (float)(arg1)->GetCurrentProgress();
38745     } catch (std::out_of_range& e) {
38746       {
38747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38748       };
38749     } catch (std::exception& e) {
38750       {
38751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38752       };
38753     } catch (...) {
38754       {
38755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38756       };
38757     }
38758   }
38759   jresult = result;
38760   return jresult;
38761 }
38762
38763
38764 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38765   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38766   float arg2 ;
38767
38768   arg1 = (Dali::Animation *)jarg1;
38769   arg2 = (float)jarg2;
38770   {
38771     try {
38772       (arg1)->SetSpeedFactor(arg2);
38773     } catch (std::out_of_range& e) {
38774       {
38775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38776       };
38777     } catch (std::exception& e) {
38778       {
38779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38780       };
38781     } catch (...) {
38782       {
38783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38784       };
38785     }
38786   }
38787 }
38788
38789
38790 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Animation_GetSpeedFactor(void * jarg1) {
38791   float jresult ;
38792   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38793   float result;
38794
38795   arg1 = (Dali::Animation *)jarg1;
38796   {
38797     try {
38798       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38799     } catch (std::out_of_range& e) {
38800       {
38801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38802       };
38803     } catch (std::exception& e) {
38804       {
38805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38806       };
38807     } catch (...) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38810       };
38811     }
38812   }
38813   jresult = result;
38814   return jresult;
38815 }
38816
38817
38818 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38819   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38820   Dali::Vector2 *arg2 = 0 ;
38821
38822   arg1 = (Dali::Animation *)jarg1;
38823   arg2 = (Dali::Vector2 *)jarg2;
38824   if (!arg2) {
38825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38826     return ;
38827   }
38828   {
38829     try {
38830       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38831     } catch (std::out_of_range& e) {
38832       {
38833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38834       };
38835     } catch (std::exception& e) {
38836       {
38837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38838       };
38839     } catch (...) {
38840       {
38841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38842       };
38843     }
38844   }
38845 }
38846
38847
38848 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_GetPlayRange(void * jarg1) {
38849   void * jresult ;
38850   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38851   Dali::Vector2 result;
38852
38853   arg1 = (Dali::Animation *)jarg1;
38854   {
38855     try {
38856       result = ((Dali::Animation const *)arg1)->GetPlayRange();
38857     } catch (std::out_of_range& e) {
38858       {
38859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (std::exception& e) {
38862       {
38863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38864       };
38865     } catch (...) {
38866       {
38867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38868       };
38869     }
38870   }
38871   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38872   return jresult;
38873 }
38874
38875
38876 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Play(void * jarg1) {
38877   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38878
38879   arg1 = (Dali::Animation *)jarg1;
38880   {
38881     try {
38882       (arg1)->Play();
38883     } catch (std::out_of_range& e) {
38884       {
38885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38886       };
38887     } catch (std::exception& e) {
38888       {
38889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38894       };
38895     }
38896   }
38897 }
38898
38899
38900 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_PlayFrom(void * jarg1, float jarg2) {
38901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38902   float arg2 ;
38903
38904   arg1 = (Dali::Animation *)jarg1;
38905   arg2 = (float)jarg2;
38906   {
38907     try {
38908       (arg1)->PlayFrom(arg2);
38909     } catch (std::out_of_range& e) {
38910       {
38911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38912       };
38913     } catch (std::exception& e) {
38914       {
38915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38916       };
38917     } catch (...) {
38918       {
38919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38920       };
38921     }
38922   }
38923 }
38924
38925
38926 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Pause(void * jarg1) {
38927   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38928
38929   arg1 = (Dali::Animation *)jarg1;
38930   {
38931     try {
38932       (arg1)->Pause();
38933     } catch (std::out_of_range& e) {
38934       {
38935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38936       };
38937     } catch (std::exception& e) {
38938       {
38939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38940       };
38941     } catch (...) {
38942       {
38943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38944       };
38945     }
38946   }
38947 }
38948
38949
38950 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Animation_GetState(void * jarg1) {
38951   int jresult ;
38952   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38953   Dali::Animation::State result;
38954
38955   arg1 = (Dali::Animation *)jarg1;
38956   {
38957     try {
38958       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
38959     } catch (std::out_of_range& e) {
38960       {
38961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38962       };
38963     } catch (std::exception& e) {
38964       {
38965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38966       };
38967     } catch (...) {
38968       {
38969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38970       };
38971     }
38972   }
38973   jresult = (int)result;
38974   return jresult;
38975 }
38976
38977
38978 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Stop(void * jarg1) {
38979   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38980
38981   arg1 = (Dali::Animation *)jarg1;
38982   {
38983     try {
38984       (arg1)->Stop();
38985     } catch (std::out_of_range& e) {
38986       {
38987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38988       };
38989     } catch (std::exception& e) {
38990       {
38991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38992       };
38993     } catch (...) {
38994       {
38995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38996       };
38997     }
38998   }
38999 }
39000
39001
39002 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Clear(void * jarg1) {
39003   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39004
39005   arg1 = (Dali::Animation *)jarg1;
39006   {
39007     try {
39008       (arg1)->Clear();
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39020       };
39021     }
39022   }
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Animation_FinishedSignal(void * jarg1) {
39027   void * jresult ;
39028   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39029   Dali::Animation::AnimationSignalType *result = 0 ;
39030
39031   arg1 = (Dali::Animation *)jarg1;
39032   {
39033     try {
39034       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39035     } catch (std::out_of_range& e) {
39036       {
39037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39038       };
39039     } catch (std::exception& e) {
39040       {
39041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39042       };
39043     } catch (...) {
39044       {
39045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39046       };
39047     }
39048   }
39049   jresult = (void *)result;
39050   return jresult;
39051 }
39052
39053
39054 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39055   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39056   SwigValueWrapper< Dali::Property > arg2 ;
39057   Dali::Property::Value arg3 ;
39058   Dali::Property *argp2 ;
39059   Dali::Property::Value *argp3 ;
39060
39061   arg1 = (Dali::Animation *)jarg1;
39062   argp2 = (Dali::Property *)jarg2;
39063   if (!argp2) {
39064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39065     return ;
39066   }
39067   arg2 = *argp2;
39068   argp3 = (Dali::Property::Value *)jarg3;
39069   if (!argp3) {
39070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39071     return ;
39072   }
39073   arg3 = *argp3;
39074   {
39075     try {
39076       (arg1)->AnimateBy(arg2,arg3);
39077     } catch (std::out_of_range& e) {
39078       {
39079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39080       };
39081     } catch (std::exception& e) {
39082       {
39083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39084       };
39085     } catch (...) {
39086       {
39087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39088       };
39089     }
39090   }
39091 }
39092
39093
39094 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39096   SwigValueWrapper< Dali::Property > arg2 ;
39097   Dali::Property::Value arg3 ;
39098   Dali::AlphaFunction arg4 ;
39099   Dali::Property *argp2 ;
39100   Dali::Property::Value *argp3 ;
39101   Dali::AlphaFunction *argp4 ;
39102
39103   arg1 = (Dali::Animation *)jarg1;
39104   argp2 = (Dali::Property *)jarg2;
39105   if (!argp2) {
39106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39107     return ;
39108   }
39109   arg2 = *argp2;
39110   argp3 = (Dali::Property::Value *)jarg3;
39111   if (!argp3) {
39112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39113     return ;
39114   }
39115   arg3 = *argp3;
39116   argp4 = (Dali::AlphaFunction *)jarg4;
39117   if (!argp4) {
39118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39119     return ;
39120   }
39121   arg4 = *argp4;
39122   {
39123     try {
39124       (arg1)->AnimateBy(arg2,arg3,arg4);
39125     } catch (std::out_of_range& e) {
39126       {
39127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39128       };
39129     } catch (std::exception& e) {
39130       {
39131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39132       };
39133     } catch (...) {
39134       {
39135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39136       };
39137     }
39138   }
39139 }
39140
39141
39142 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39143   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39144   SwigValueWrapper< Dali::Property > arg2 ;
39145   Dali::Property::Value arg3 ;
39146   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39147   Dali::Property *argp2 ;
39148   Dali::Property::Value *argp3 ;
39149   Dali::TimePeriod *argp4 ;
39150
39151   arg1 = (Dali::Animation *)jarg1;
39152   argp2 = (Dali::Property *)jarg2;
39153   if (!argp2) {
39154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39155     return ;
39156   }
39157   arg2 = *argp2;
39158   argp3 = (Dali::Property::Value *)jarg3;
39159   if (!argp3) {
39160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39161     return ;
39162   }
39163   arg3 = *argp3;
39164   argp4 = (Dali::TimePeriod *)jarg4;
39165   if (!argp4) {
39166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39167     return ;
39168   }
39169   arg4 = *argp4;
39170   {
39171     try {
39172       (arg1)->AnimateBy(arg2,arg3,arg4);
39173     } catch (std::out_of_range& e) {
39174       {
39175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39176       };
39177     } catch (std::exception& e) {
39178       {
39179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39180       };
39181     } catch (...) {
39182       {
39183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39184       };
39185     }
39186   }
39187 }
39188
39189
39190 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39191   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39192   SwigValueWrapper< Dali::Property > arg2 ;
39193   Dali::Property::Value arg3 ;
39194   Dali::AlphaFunction arg4 ;
39195   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39196   Dali::Property *argp2 ;
39197   Dali::Property::Value *argp3 ;
39198   Dali::AlphaFunction *argp4 ;
39199   Dali::TimePeriod *argp5 ;
39200
39201   arg1 = (Dali::Animation *)jarg1;
39202   argp2 = (Dali::Property *)jarg2;
39203   if (!argp2) {
39204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39205     return ;
39206   }
39207   arg2 = *argp2;
39208   argp3 = (Dali::Property::Value *)jarg3;
39209   if (!argp3) {
39210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39211     return ;
39212   }
39213   arg3 = *argp3;
39214   argp4 = (Dali::AlphaFunction *)jarg4;
39215   if (!argp4) {
39216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39217     return ;
39218   }
39219   arg4 = *argp4;
39220   argp5 = (Dali::TimePeriod *)jarg5;
39221   if (!argp5) {
39222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39223     return ;
39224   }
39225   arg5 = *argp5;
39226   {
39227     try {
39228       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39229     } catch (std::out_of_range& e) {
39230       {
39231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39232       };
39233     } catch (std::exception& e) {
39234       {
39235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39236       };
39237     } catch (...) {
39238       {
39239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39240       };
39241     }
39242   }
39243 }
39244
39245
39246 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39247   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39248   SwigValueWrapper< Dali::Property > arg2 ;
39249   Dali::Property::Value arg3 ;
39250   Dali::Property *argp2 ;
39251   Dali::Property::Value *argp3 ;
39252
39253   arg1 = (Dali::Animation *)jarg1;
39254   argp2 = (Dali::Property *)jarg2;
39255   if (!argp2) {
39256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39257     return ;
39258   }
39259   arg2 = *argp2;
39260   argp3 = (Dali::Property::Value *)jarg3;
39261   if (!argp3) {
39262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39263     return ;
39264   }
39265   arg3 = *argp3;
39266   {
39267     try {
39268       (arg1)->AnimateTo(arg2,arg3);
39269     } catch (std::out_of_range& e) {
39270       {
39271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (std::exception& e) {
39274       {
39275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283 }
39284
39285
39286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39287   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39288   SwigValueWrapper< Dali::Property > arg2 ;
39289   Dali::Property::Value arg3 ;
39290   Dali::AlphaFunction arg4 ;
39291   Dali::Property *argp2 ;
39292   Dali::Property::Value *argp3 ;
39293   Dali::AlphaFunction *argp4 ;
39294
39295   arg1 = (Dali::Animation *)jarg1;
39296   argp2 = (Dali::Property *)jarg2;
39297   if (!argp2) {
39298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39299     return ;
39300   }
39301   arg2 = *argp2;
39302   argp3 = (Dali::Property::Value *)jarg3;
39303   if (!argp3) {
39304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39305     return ;
39306   }
39307   arg3 = *argp3;
39308   argp4 = (Dali::AlphaFunction *)jarg4;
39309   if (!argp4) {
39310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39311     return ;
39312   }
39313   arg4 = *argp4;
39314   {
39315     try {
39316       (arg1)->AnimateTo(arg2,arg3,arg4);
39317     } catch (std::out_of_range& e) {
39318       {
39319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39320       };
39321     } catch (std::exception& e) {
39322       {
39323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39324       };
39325     } catch (...) {
39326       {
39327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39328       };
39329     }
39330   }
39331 }
39332
39333
39334 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39335   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39336   SwigValueWrapper< Dali::Property > arg2 ;
39337   Dali::Property::Value arg3 ;
39338   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39339   Dali::Property *argp2 ;
39340   Dali::Property::Value *argp3 ;
39341   Dali::TimePeriod *argp4 ;
39342
39343   arg1 = (Dali::Animation *)jarg1;
39344   argp2 = (Dali::Property *)jarg2;
39345   if (!argp2) {
39346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39347     return ;
39348   }
39349   arg2 = *argp2;
39350   argp3 = (Dali::Property::Value *)jarg3;
39351   if (!argp3) {
39352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39353     return ;
39354   }
39355   arg3 = *argp3;
39356   argp4 = (Dali::TimePeriod *)jarg4;
39357   if (!argp4) {
39358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39359     return ;
39360   }
39361   arg4 = *argp4;
39362   {
39363     try {
39364       (arg1)->AnimateTo(arg2,arg3,arg4);
39365     } catch (std::out_of_range& e) {
39366       {
39367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39368       };
39369     } catch (std::exception& e) {
39370       {
39371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39372       };
39373     } catch (...) {
39374       {
39375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39376       };
39377     }
39378   }
39379 }
39380
39381
39382 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39383   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39384   SwigValueWrapper< Dali::Property > arg2 ;
39385   Dali::Property::Value arg3 ;
39386   Dali::AlphaFunction arg4 ;
39387   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39388   Dali::Property *argp2 ;
39389   Dali::Property::Value *argp3 ;
39390   Dali::AlphaFunction *argp4 ;
39391   Dali::TimePeriod *argp5 ;
39392
39393   arg1 = (Dali::Animation *)jarg1;
39394   argp2 = (Dali::Property *)jarg2;
39395   if (!argp2) {
39396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39397     return ;
39398   }
39399   arg2 = *argp2;
39400   argp3 = (Dali::Property::Value *)jarg3;
39401   if (!argp3) {
39402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39403     return ;
39404   }
39405   arg3 = *argp3;
39406   argp4 = (Dali::AlphaFunction *)jarg4;
39407   if (!argp4) {
39408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39409     return ;
39410   }
39411   arg4 = *argp4;
39412   argp5 = (Dali::TimePeriod *)jarg5;
39413   if (!argp5) {
39414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39415     return ;
39416   }
39417   arg5 = *argp5;
39418   {
39419     try {
39420       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39432       };
39433     }
39434   }
39435 }
39436
39437
39438 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39439   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39440   SwigValueWrapper< Dali::Property > arg2 ;
39441   Dali::KeyFrames *arg3 = 0 ;
39442   Dali::Property *argp2 ;
39443
39444   arg1 = (Dali::Animation *)jarg1;
39445   argp2 = (Dali::Property *)jarg2;
39446   if (!argp2) {
39447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39448     return ;
39449   }
39450   arg2 = *argp2;
39451   arg3 = (Dali::KeyFrames *)jarg3;
39452   if (!arg3) {
39453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39454     return ;
39455   }
39456   {
39457     try {
39458       (arg1)->AnimateBetween(arg2,*arg3);
39459     } catch (std::out_of_range& e) {
39460       {
39461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39462       };
39463     } catch (std::exception& e) {
39464       {
39465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39466       };
39467     } catch (...) {
39468       {
39469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39470       };
39471     }
39472   }
39473 }
39474
39475
39476 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39477   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39478   SwigValueWrapper< Dali::Property > arg2 ;
39479   Dali::KeyFrames *arg3 = 0 ;
39480   Dali::Animation::Interpolation arg4 ;
39481   Dali::Property *argp2 ;
39482
39483   arg1 = (Dali::Animation *)jarg1;
39484   argp2 = (Dali::Property *)jarg2;
39485   if (!argp2) {
39486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39487     return ;
39488   }
39489   arg2 = *argp2;
39490   arg3 = (Dali::KeyFrames *)jarg3;
39491   if (!arg3) {
39492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39493     return ;
39494   }
39495   arg4 = (Dali::Animation::Interpolation)jarg4;
39496   {
39497     try {
39498       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39499     } catch (std::out_of_range& e) {
39500       {
39501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39502       };
39503     } catch (std::exception& e) {
39504       {
39505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39506       };
39507     } catch (...) {
39508       {
39509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39510       };
39511     }
39512   }
39513 }
39514
39515
39516 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39517   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39518   SwigValueWrapper< Dali::Property > arg2 ;
39519   Dali::KeyFrames *arg3 = 0 ;
39520   Dali::AlphaFunction arg4 ;
39521   Dali::Property *argp2 ;
39522   Dali::AlphaFunction *argp4 ;
39523
39524   arg1 = (Dali::Animation *)jarg1;
39525   argp2 = (Dali::Property *)jarg2;
39526   if (!argp2) {
39527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39528     return ;
39529   }
39530   arg2 = *argp2;
39531   arg3 = (Dali::KeyFrames *)jarg3;
39532   if (!arg3) {
39533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39534     return ;
39535   }
39536   argp4 = (Dali::AlphaFunction *)jarg4;
39537   if (!argp4) {
39538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39539     return ;
39540   }
39541   arg4 = *argp4;
39542   {
39543     try {
39544       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39552       };
39553     } catch (...) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39556       };
39557     }
39558   }
39559 }
39560
39561
39562 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39563   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39564   SwigValueWrapper< Dali::Property > arg2 ;
39565   Dali::KeyFrames *arg3 = 0 ;
39566   Dali::AlphaFunction arg4 ;
39567   Dali::Animation::Interpolation arg5 ;
39568   Dali::Property *argp2 ;
39569   Dali::AlphaFunction *argp4 ;
39570
39571   arg1 = (Dali::Animation *)jarg1;
39572   argp2 = (Dali::Property *)jarg2;
39573   if (!argp2) {
39574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39575     return ;
39576   }
39577   arg2 = *argp2;
39578   arg3 = (Dali::KeyFrames *)jarg3;
39579   if (!arg3) {
39580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39581     return ;
39582   }
39583   argp4 = (Dali::AlphaFunction *)jarg4;
39584   if (!argp4) {
39585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39586     return ;
39587   }
39588   arg4 = *argp4;
39589   arg5 = (Dali::Animation::Interpolation)jarg5;
39590   {
39591     try {
39592       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39593     } catch (std::out_of_range& e) {
39594       {
39595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39596       };
39597     } catch (std::exception& e) {
39598       {
39599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39600       };
39601     } catch (...) {
39602       {
39603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39604       };
39605     }
39606   }
39607 }
39608
39609
39610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39611   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39612   SwigValueWrapper< Dali::Property > arg2 ;
39613   Dali::KeyFrames *arg3 = 0 ;
39614   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39615   Dali::Property *argp2 ;
39616   Dali::TimePeriod *argp4 ;
39617
39618   arg1 = (Dali::Animation *)jarg1;
39619   argp2 = (Dali::Property *)jarg2;
39620   if (!argp2) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39622     return ;
39623   }
39624   arg2 = *argp2;
39625   arg3 = (Dali::KeyFrames *)jarg3;
39626   if (!arg3) {
39627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39628     return ;
39629   }
39630   argp4 = (Dali::TimePeriod *)jarg4;
39631   if (!argp4) {
39632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39633     return ;
39634   }
39635   arg4 = *argp4;
39636   {
39637     try {
39638       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39639     } catch (std::out_of_range& e) {
39640       {
39641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39642       };
39643     } catch (std::exception& e) {
39644       {
39645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39646       };
39647     } catch (...) {
39648       {
39649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39650       };
39651     }
39652   }
39653 }
39654
39655
39656 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39657   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39658   SwigValueWrapper< Dali::Property > arg2 ;
39659   Dali::KeyFrames *arg3 = 0 ;
39660   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39661   Dali::Animation::Interpolation arg5 ;
39662   Dali::Property *argp2 ;
39663   Dali::TimePeriod *argp4 ;
39664
39665   arg1 = (Dali::Animation *)jarg1;
39666   argp2 = (Dali::Property *)jarg2;
39667   if (!argp2) {
39668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39669     return ;
39670   }
39671   arg2 = *argp2;
39672   arg3 = (Dali::KeyFrames *)jarg3;
39673   if (!arg3) {
39674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39675     return ;
39676   }
39677   argp4 = (Dali::TimePeriod *)jarg4;
39678   if (!argp4) {
39679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39680     return ;
39681   }
39682   arg4 = *argp4;
39683   arg5 = (Dali::Animation::Interpolation)jarg5;
39684   {
39685     try {
39686       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39687     } catch (std::out_of_range& e) {
39688       {
39689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39690       };
39691     } catch (std::exception& e) {
39692       {
39693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39694       };
39695     } catch (...) {
39696       {
39697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39698       };
39699     }
39700   }
39701 }
39702
39703
39704 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39705   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39706   SwigValueWrapper< Dali::Property > arg2 ;
39707   Dali::KeyFrames *arg3 = 0 ;
39708   Dali::AlphaFunction arg4 ;
39709   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39710   Dali::Property *argp2 ;
39711   Dali::AlphaFunction *argp4 ;
39712   Dali::TimePeriod *argp5 ;
39713
39714   arg1 = (Dali::Animation *)jarg1;
39715   argp2 = (Dali::Property *)jarg2;
39716   if (!argp2) {
39717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39718     return ;
39719   }
39720   arg2 = *argp2;
39721   arg3 = (Dali::KeyFrames *)jarg3;
39722   if (!arg3) {
39723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39724     return ;
39725   }
39726   argp4 = (Dali::AlphaFunction *)jarg4;
39727   if (!argp4) {
39728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39729     return ;
39730   }
39731   arg4 = *argp4;
39732   argp5 = (Dali::TimePeriod *)jarg5;
39733   if (!argp5) {
39734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39735     return ;
39736   }
39737   arg5 = *argp5;
39738   {
39739     try {
39740       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39741     } catch (std::out_of_range& e) {
39742       {
39743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39744       };
39745     } catch (std::exception& e) {
39746       {
39747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39748       };
39749     } catch (...) {
39750       {
39751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39752       };
39753     }
39754   }
39755 }
39756
39757
39758 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39759   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39760   SwigValueWrapper< Dali::Property > arg2 ;
39761   Dali::KeyFrames *arg3 = 0 ;
39762   Dali::AlphaFunction arg4 ;
39763   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39764   Dali::Animation::Interpolation arg6 ;
39765   Dali::Property *argp2 ;
39766   Dali::AlphaFunction *argp4 ;
39767   Dali::TimePeriod *argp5 ;
39768
39769   arg1 = (Dali::Animation *)jarg1;
39770   argp2 = (Dali::Property *)jarg2;
39771   if (!argp2) {
39772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39773     return ;
39774   }
39775   arg2 = *argp2;
39776   arg3 = (Dali::KeyFrames *)jarg3;
39777   if (!arg3) {
39778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39779     return ;
39780   }
39781   argp4 = (Dali::AlphaFunction *)jarg4;
39782   if (!argp4) {
39783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39784     return ;
39785   }
39786   arg4 = *argp4;
39787   argp5 = (Dali::TimePeriod *)jarg5;
39788   if (!argp5) {
39789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39790     return ;
39791   }
39792   arg5 = *argp5;
39793   arg6 = (Dali::Animation::Interpolation)jarg6;
39794   {
39795     try {
39796       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39797     } catch (std::out_of_range& e) {
39798       {
39799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39800       };
39801     } catch (std::exception& e) {
39802       {
39803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39804       };
39805     } catch (...) {
39806       {
39807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39808       };
39809     }
39810   }
39811 }
39812
39813
39814 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39815   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39816   Dali::Actor arg2 ;
39817   Dali::Path arg3 ;
39818   Dali::Vector3 *arg4 = 0 ;
39819   Dali::Actor *argp2 ;
39820   Dali::Path *argp3 ;
39821
39822   arg1 = (Dali::Animation *)jarg1;
39823   argp2 = (Dali::Actor *)jarg2;
39824   if (!argp2) {
39825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39826     return ;
39827   }
39828   arg2 = *argp2;
39829   argp3 = (Dali::Path *)jarg3;
39830   if (!argp3) {
39831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39832     return ;
39833   }
39834   arg3 = *argp3;
39835   arg4 = (Dali::Vector3 *)jarg4;
39836   if (!arg4) {
39837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39838     return ;
39839   }
39840   {
39841     try {
39842       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
39843     } catch (std::out_of_range& e) {
39844       {
39845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39846       };
39847     } catch (std::exception& e) {
39848       {
39849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39850       };
39851     } catch (...) {
39852       {
39853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39854       };
39855     }
39856   }
39857 }
39858
39859
39860 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39861   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39862   Dali::Actor arg2 ;
39863   Dali::Path arg3 ;
39864   Dali::Vector3 *arg4 = 0 ;
39865   Dali::AlphaFunction arg5 ;
39866   Dali::Actor *argp2 ;
39867   Dali::Path *argp3 ;
39868   Dali::AlphaFunction *argp5 ;
39869
39870   arg1 = (Dali::Animation *)jarg1;
39871   argp2 = (Dali::Actor *)jarg2;
39872   if (!argp2) {
39873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39874     return ;
39875   }
39876   arg2 = *argp2;
39877   argp3 = (Dali::Path *)jarg3;
39878   if (!argp3) {
39879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39880     return ;
39881   }
39882   arg3 = *argp3;
39883   arg4 = (Dali::Vector3 *)jarg4;
39884   if (!arg4) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39886     return ;
39887   }
39888   argp5 = (Dali::AlphaFunction *)jarg5;
39889   if (!argp5) {
39890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39891     return ;
39892   }
39893   arg5 = *argp5;
39894   {
39895     try {
39896       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911 }
39912
39913
39914 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39915   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39916   Dali::Actor arg2 ;
39917   Dali::Path arg3 ;
39918   Dali::Vector3 *arg4 = 0 ;
39919   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39920   Dali::Actor *argp2 ;
39921   Dali::Path *argp3 ;
39922   Dali::TimePeriod *argp5 ;
39923
39924   arg1 = (Dali::Animation *)jarg1;
39925   argp2 = (Dali::Actor *)jarg2;
39926   if (!argp2) {
39927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39928     return ;
39929   }
39930   arg2 = *argp2;
39931   argp3 = (Dali::Path *)jarg3;
39932   if (!argp3) {
39933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39934     return ;
39935   }
39936   arg3 = *argp3;
39937   arg4 = (Dali::Vector3 *)jarg4;
39938   if (!arg4) {
39939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39940     return ;
39941   }
39942   argp5 = (Dali::TimePeriod *)jarg5;
39943   if (!argp5) {
39944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39945     return ;
39946   }
39947   arg5 = *argp5;
39948   {
39949     try {
39950       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39951     } catch (std::out_of_range& e) {
39952       {
39953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39954       };
39955     } catch (std::exception& e) {
39956       {
39957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39958       };
39959     } catch (...) {
39960       {
39961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39962       };
39963     }
39964   }
39965 }
39966
39967
39968 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
39969   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39970   Dali::Actor arg2 ;
39971   Dali::Path arg3 ;
39972   Dali::Vector3 *arg4 = 0 ;
39973   Dali::AlphaFunction arg5 ;
39974   SwigValueWrapper< Dali::TimePeriod > arg6 ;
39975   Dali::Actor *argp2 ;
39976   Dali::Path *argp3 ;
39977   Dali::AlphaFunction *argp5 ;
39978   Dali::TimePeriod *argp6 ;
39979
39980   arg1 = (Dali::Animation *)jarg1;
39981   argp2 = (Dali::Actor *)jarg2;
39982   if (!argp2) {
39983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39984     return ;
39985   }
39986   arg2 = *argp2;
39987   argp3 = (Dali::Path *)jarg3;
39988   if (!argp3) {
39989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39990     return ;
39991   }
39992   arg3 = *argp3;
39993   arg4 = (Dali::Vector3 *)jarg4;
39994   if (!arg4) {
39995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39996     return ;
39997   }
39998   argp5 = (Dali::AlphaFunction *)jarg5;
39999   if (!argp5) {
40000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40001     return ;
40002   }
40003   arg5 = *argp5;
40004   argp6 = (Dali::TimePeriod *)jarg6;
40005   if (!argp6) {
40006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40007     return ;
40008   }
40009   arg6 = *argp6;
40010   {
40011     try {
40012       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40013     } catch (std::out_of_range& e) {
40014       {
40015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40016       };
40017     } catch (std::exception& e) {
40018       {
40019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40020       };
40021     } catch (...) {
40022       {
40023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40024       };
40025     }
40026   }
40027 }
40028
40029
40030 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40031   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40032   Dali::Actor arg2 ;
40033   float arg3 ;
40034   Dali::Actor *argp2 ;
40035
40036   arg1 = (Dali::Animation *)jarg1;
40037   argp2 = (Dali::Actor *)jarg2;
40038   if (!argp2) {
40039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40040     return ;
40041   }
40042   arg2 = *argp2;
40043   arg3 = (float)jarg3;
40044   {
40045     try {
40046       (arg1)->Show(arg2,arg3);
40047     } catch (std::out_of_range& e) {
40048       {
40049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40050       };
40051     } catch (std::exception& e) {
40052       {
40053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40054       };
40055     } catch (...) {
40056       {
40057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40058       };
40059     }
40060   }
40061 }
40062
40063
40064 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40065   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40066   Dali::Actor arg2 ;
40067   float arg3 ;
40068   Dali::Actor *argp2 ;
40069
40070   arg1 = (Dali::Animation *)jarg1;
40071   argp2 = (Dali::Actor *)jarg2;
40072   if (!argp2) {
40073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40074     return ;
40075   }
40076   arg2 = *argp2;
40077   arg3 = (float)jarg3;
40078   {
40079     try {
40080       (arg1)->Hide(arg2,arg3);
40081     } catch (std::out_of_range& e) {
40082       {
40083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40084       };
40085     } catch (std::exception& e) {
40086       {
40087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40088       };
40089     } catch (...) {
40090       {
40091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40092       };
40093     }
40094   }
40095 }
40096
40097
40098 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LinearConstrainer_Property_VALUE_get() {
40099   int jresult ;
40100   int result;
40101
40102   result = (int)Dali::LinearConstrainer::Property::VALUE;
40103   jresult = (int)result;
40104   return jresult;
40105 }
40106
40107
40108 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LinearConstrainer_Property_PROGRESS_get() {
40109   int jresult ;
40110   int result;
40111
40112   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40113   jresult = (int)result;
40114   return jresult;
40115 }
40116
40117
40118 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer_Property() {
40119   void * jresult ;
40120   Dali::LinearConstrainer::Property *result = 0 ;
40121
40122   {
40123     try {
40124       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40125     } catch (std::out_of_range& e) {
40126       {
40127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40128       };
40129     } catch (std::exception& e) {
40130       {
40131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40136       };
40137     }
40138   }
40139   jresult = (void *)result;
40140   return jresult;
40141 }
40142
40143
40144 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LinearConstrainer_Property(void * jarg1) {
40145   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40146
40147   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40148   {
40149     try {
40150       delete arg1;
40151     } catch (std::out_of_range& e) {
40152       {
40153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40154       };
40155     } catch (std::exception& e) {
40156       {
40157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40158       };
40159     } catch (...) {
40160       {
40161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40162       };
40163     }
40164   }
40165 }
40166
40167
40168 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_New() {
40169   void * jresult ;
40170   Dali::LinearConstrainer result;
40171
40172   {
40173     try {
40174       result = Dali::LinearConstrainer::New();
40175     } catch (std::out_of_range& e) {
40176       {
40177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40178       };
40179     } catch (std::exception& e) {
40180       {
40181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40182       };
40183     } catch (...) {
40184       {
40185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40186       };
40187     }
40188   }
40189   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40190   return jresult;
40191 }
40192
40193
40194 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_DownCast(void * jarg1) {
40195   void * jresult ;
40196   Dali::BaseHandle arg1 ;
40197   Dali::BaseHandle *argp1 ;
40198   Dali::LinearConstrainer result;
40199
40200   argp1 = (Dali::BaseHandle *)jarg1;
40201   if (!argp1) {
40202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40203     return 0;
40204   }
40205   arg1 = *argp1;
40206   {
40207     try {
40208       result = Dali::LinearConstrainer::DownCast(arg1);
40209     } catch (std::out_of_range& e) {
40210       {
40211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40212       };
40213     } catch (std::exception& e) {
40214       {
40215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40216       };
40217     } catch (...) {
40218       {
40219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40220       };
40221     }
40222   }
40223   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40224   return jresult;
40225 }
40226
40227
40228 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer__SWIG_0() {
40229   void * jresult ;
40230   Dali::LinearConstrainer *result = 0 ;
40231
40232   {
40233     try {
40234       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40246       };
40247     }
40248   }
40249   jresult = (void *)result;
40250   return jresult;
40251 }
40252
40253
40254 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LinearConstrainer(void * jarg1) {
40255   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40256
40257   arg1 = (Dali::LinearConstrainer *)jarg1;
40258   {
40259     try {
40260       delete arg1;
40261     } catch (std::out_of_range& e) {
40262       {
40263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40264       };
40265     } catch (std::exception& e) {
40266       {
40267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40272       };
40273     }
40274   }
40275 }
40276
40277
40278 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LinearConstrainer__SWIG_1(void * jarg1) {
40279   void * jresult ;
40280   Dali::LinearConstrainer *arg1 = 0 ;
40281   Dali::LinearConstrainer *result = 0 ;
40282
40283   arg1 = (Dali::LinearConstrainer *)jarg1;
40284   if (!arg1) {
40285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40286     return 0;
40287   }
40288   {
40289     try {
40290       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40291     } catch (std::out_of_range& e) {
40292       {
40293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (std::exception& e) {
40296       {
40297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40298       };
40299     } catch (...) {
40300       {
40301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40302       };
40303     }
40304   }
40305   jresult = (void *)result;
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40311   void * jresult ;
40312   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40313   Dali::LinearConstrainer *arg2 = 0 ;
40314   Dali::LinearConstrainer *result = 0 ;
40315
40316   arg1 = (Dali::LinearConstrainer *)jarg1;
40317   arg2 = (Dali::LinearConstrainer *)jarg2;
40318   if (!arg2) {
40319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40320     return 0;
40321   }
40322   {
40323     try {
40324       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40325     } catch (std::out_of_range& e) {
40326       {
40327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40328       };
40329     } catch (std::exception& e) {
40330       {
40331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40332       };
40333     } catch (...) {
40334       {
40335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40336       };
40337     }
40338   }
40339   jresult = (void *)result;
40340   return jresult;
40341 }
40342
40343
40344 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40345   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40346   SwigValueWrapper< Dali::Property > arg2 ;
40347   SwigValueWrapper< Dali::Property > arg3 ;
40348   Dali::Vector2 *arg4 = 0 ;
40349   Dali::Vector2 *arg5 = 0 ;
40350   Dali::Property *argp2 ;
40351   Dali::Property *argp3 ;
40352
40353   arg1 = (Dali::LinearConstrainer *)jarg1;
40354   argp2 = (Dali::Property *)jarg2;
40355   if (!argp2) {
40356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40357     return ;
40358   }
40359   arg2 = *argp2;
40360   argp3 = (Dali::Property *)jarg3;
40361   if (!argp3) {
40362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40363     return ;
40364   }
40365   arg3 = *argp3;
40366   arg4 = (Dali::Vector2 *)jarg4;
40367   if (!arg4) {
40368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40369     return ;
40370   }
40371   arg5 = (Dali::Vector2 *)jarg5;
40372   if (!arg5) {
40373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40374     return ;
40375   }
40376   {
40377     try {
40378       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40379     } catch (std::out_of_range& e) {
40380       {
40381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40382       };
40383     } catch (std::exception& e) {
40384       {
40385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40386       };
40387     } catch (...) {
40388       {
40389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40390       };
40391     }
40392   }
40393 }
40394
40395
40396 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40397   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40398   SwigValueWrapper< Dali::Property > arg2 ;
40399   SwigValueWrapper< Dali::Property > arg3 ;
40400   Dali::Vector2 *arg4 = 0 ;
40401   Dali::Property *argp2 ;
40402   Dali::Property *argp3 ;
40403
40404   arg1 = (Dali::LinearConstrainer *)jarg1;
40405   argp2 = (Dali::Property *)jarg2;
40406   if (!argp2) {
40407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40408     return ;
40409   }
40410   arg2 = *argp2;
40411   argp3 = (Dali::Property *)jarg3;
40412   if (!argp3) {
40413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40414     return ;
40415   }
40416   arg3 = *argp3;
40417   arg4 = (Dali::Vector2 *)jarg4;
40418   if (!arg4) {
40419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40420     return ;
40421   }
40422   {
40423     try {
40424       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40425     } catch (std::out_of_range& e) {
40426       {
40427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40428       };
40429     } catch (std::exception& e) {
40430       {
40431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40432       };
40433     } catch (...) {
40434       {
40435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40436       };
40437     }
40438   }
40439 }
40440
40441
40442 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40443   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40444   Dali::Handle *arg2 = 0 ;
40445
40446   arg1 = (Dali::LinearConstrainer *)jarg1;
40447   arg2 = (Dali::Handle *)jarg2;
40448   if (!arg2) {
40449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40450     return ;
40451   }
40452   {
40453     try {
40454       (arg1)->Remove(*arg2);
40455     } catch (std::out_of_range& e) {
40456       {
40457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (std::exception& e) {
40460       {
40461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40462       };
40463     } catch (...) {
40464       {
40465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40466       };
40467     }
40468   }
40469 }
40470
40471
40472 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_FORWARD_get() {
40473   int jresult ;
40474   int result;
40475
40476   result = (int)Dali::PathConstrainer::Property::FORWARD;
40477   jresult = (int)result;
40478   return jresult;
40479 }
40480
40481
40482 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_POINTS_get() {
40483   int jresult ;
40484   int result;
40485
40486   result = (int)Dali::PathConstrainer::Property::POINTS;
40487   jresult = (int)result;
40488   return jresult;
40489 }
40490
40491
40492 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PathConstrainer_Property_CONTROL_POINTS_get() {
40493   int jresult ;
40494   int result;
40495
40496   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40497   jresult = (int)result;
40498   return jresult;
40499 }
40500
40501
40502 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer_Property() {
40503   void * jresult ;
40504   Dali::PathConstrainer::Property *result = 0 ;
40505
40506   {
40507     try {
40508       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40509     } catch (std::out_of_range& e) {
40510       {
40511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40512       };
40513     } catch (std::exception& e) {
40514       {
40515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40516       };
40517     } catch (...) {
40518       {
40519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40520       };
40521     }
40522   }
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PathConstrainer_Property(void * jarg1) {
40529   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40530
40531   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40532   {
40533     try {
40534       delete arg1;
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40542       };
40543     } catch (...) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40546       };
40547     }
40548   }
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_New() {
40553   void * jresult ;
40554   Dali::PathConstrainer result;
40555
40556   {
40557     try {
40558       result = Dali::PathConstrainer::New();
40559     } catch (std::out_of_range& e) {
40560       {
40561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40562       };
40563     } catch (std::exception& e) {
40564       {
40565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (...) {
40568       {
40569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40570       };
40571     }
40572   }
40573   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40574   return jresult;
40575 }
40576
40577
40578 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_DownCast(void * jarg1) {
40579   void * jresult ;
40580   Dali::BaseHandle arg1 ;
40581   Dali::BaseHandle *argp1 ;
40582   Dali::PathConstrainer result;
40583
40584   argp1 = (Dali::BaseHandle *)jarg1;
40585   if (!argp1) {
40586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40587     return 0;
40588   }
40589   arg1 = *argp1;
40590   {
40591     try {
40592       result = Dali::PathConstrainer::DownCast(arg1);
40593     } catch (std::out_of_range& e) {
40594       {
40595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (std::exception& e) {
40598       {
40599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40600       };
40601     } catch (...) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40604       };
40605     }
40606   }
40607   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40608   return jresult;
40609 }
40610
40611
40612 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer__SWIG_0() {
40613   void * jresult ;
40614   Dali::PathConstrainer *result = 0 ;
40615
40616   {
40617     try {
40618       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40619     } catch (std::out_of_range& e) {
40620       {
40621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40622       };
40623     } catch (std::exception& e) {
40624       {
40625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40626       };
40627     } catch (...) {
40628       {
40629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40630       };
40631     }
40632   }
40633   jresult = (void *)result;
40634   return jresult;
40635 }
40636
40637
40638 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PathConstrainer(void * jarg1) {
40639   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40640
40641   arg1 = (Dali::PathConstrainer *)jarg1;
40642   {
40643     try {
40644       delete arg1;
40645     } catch (std::out_of_range& e) {
40646       {
40647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40648       };
40649     } catch (std::exception& e) {
40650       {
40651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40652       };
40653     } catch (...) {
40654       {
40655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40656       };
40657     }
40658   }
40659 }
40660
40661
40662 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PathConstrainer__SWIG_1(void * jarg1) {
40663   void * jresult ;
40664   Dali::PathConstrainer *arg1 = 0 ;
40665   Dali::PathConstrainer *result = 0 ;
40666
40667   arg1 = (Dali::PathConstrainer *)jarg1;
40668   if (!arg1) {
40669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40670     return 0;
40671   }
40672   {
40673     try {
40674       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40675     } catch (std::out_of_range& e) {
40676       {
40677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (std::exception& e) {
40680       {
40681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40682       };
40683     } catch (...) {
40684       {
40685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40686       };
40687     }
40688   }
40689   jresult = (void *)result;
40690   return jresult;
40691 }
40692
40693
40694 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40695   void * jresult ;
40696   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40697   Dali::PathConstrainer *arg2 = 0 ;
40698   Dali::PathConstrainer *result = 0 ;
40699
40700   arg1 = (Dali::PathConstrainer *)jarg1;
40701   arg2 = (Dali::PathConstrainer *)jarg2;
40702   if (!arg2) {
40703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40704     return 0;
40705   }
40706   {
40707     try {
40708       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40709     } catch (std::out_of_range& e) {
40710       {
40711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40712       };
40713     } catch (std::exception& e) {
40714       {
40715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40716       };
40717     } catch (...) {
40718       {
40719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40720       };
40721     }
40722   }
40723   jresult = (void *)result;
40724   return jresult;
40725 }
40726
40727
40728 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40729   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40730   SwigValueWrapper< Dali::Property > arg2 ;
40731   SwigValueWrapper< Dali::Property > arg3 ;
40732   Dali::Vector2 *arg4 = 0 ;
40733   Dali::Vector2 *arg5 = 0 ;
40734   Dali::Property *argp2 ;
40735   Dali::Property *argp3 ;
40736
40737   arg1 = (Dali::PathConstrainer *)jarg1;
40738   argp2 = (Dali::Property *)jarg2;
40739   if (!argp2) {
40740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40741     return ;
40742   }
40743   arg2 = *argp2;
40744   argp3 = (Dali::Property *)jarg3;
40745   if (!argp3) {
40746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40747     return ;
40748   }
40749   arg3 = *argp3;
40750   arg4 = (Dali::Vector2 *)jarg4;
40751   if (!arg4) {
40752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40753     return ;
40754   }
40755   arg5 = (Dali::Vector2 *)jarg5;
40756   if (!arg5) {
40757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40758     return ;
40759   }
40760   {
40761     try {
40762       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40774       };
40775     }
40776   }
40777 }
40778
40779
40780 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40781   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40782   SwigValueWrapper< Dali::Property > arg2 ;
40783   SwigValueWrapper< Dali::Property > arg3 ;
40784   Dali::Vector2 *arg4 = 0 ;
40785   Dali::Property *argp2 ;
40786   Dali::Property *argp3 ;
40787
40788   arg1 = (Dali::PathConstrainer *)jarg1;
40789   argp2 = (Dali::Property *)jarg2;
40790   if (!argp2) {
40791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40792     return ;
40793   }
40794   arg2 = *argp2;
40795   argp3 = (Dali::Property *)jarg3;
40796   if (!argp3) {
40797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40798     return ;
40799   }
40800   arg3 = *argp3;
40801   arg4 = (Dali::Vector2 *)jarg4;
40802   if (!arg4) {
40803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40804     return ;
40805   }
40806   {
40807     try {
40808       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40809     } catch (std::out_of_range& e) {
40810       {
40811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40812       };
40813     } catch (std::exception& e) {
40814       {
40815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40816       };
40817     } catch (...) {
40818       {
40819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40820       };
40821     }
40822   }
40823 }
40824
40825
40826 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40827   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40828   Dali::Handle *arg2 = 0 ;
40829
40830   arg1 = (Dali::PathConstrainer *)jarg1;
40831   arg2 = (Dali::Handle *)jarg2;
40832   if (!arg2) {
40833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40834     return ;
40835   }
40836   {
40837     try {
40838       (arg1)->Remove(*arg2);
40839     } catch (std::out_of_range& e) {
40840       {
40841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40842       };
40843     } catch (std::exception& e) {
40844       {
40845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40846       };
40847     } catch (...) {
40848       {
40849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40850       };
40851     }
40852   }
40853 }
40854
40855
40856 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FittingModeDefault_get() {
40857   int jresult ;
40858   Dali::FittingMode::Type result;
40859
40860   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
40861   jresult = (int)result;
40862   return jresult;
40863 }
40864
40865
40866 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_DEFAULT_get() {
40867   int jresult ;
40868   Dali::SamplingMode::Type result;
40869
40870   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
40871   jresult = (int)result;
40872   return jresult;
40873 }
40874
40875
40876 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BufferImage__SWIG_0() {
40877   void * jresult ;
40878   Dali::BufferImage *result = 0 ;
40879
40880   {
40881     try {
40882       result = (Dali::BufferImage *)new Dali::BufferImage();
40883     } catch (std::out_of_range& e) {
40884       {
40885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40886       };
40887     } catch (std::exception& e) {
40888       {
40889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40890       };
40891     } catch (...) {
40892       {
40893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40894       };
40895     }
40896   }
40897   jresult = (void *)result;
40898   return jresult;
40899 }
40900
40901
40902 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
40903   void * jresult ;
40904   unsigned int arg1 ;
40905   unsigned int arg2 ;
40906   Dali::Pixel::Format arg3 ;
40907   Dali::BufferImage result;
40908
40909   arg1 = (unsigned int)jarg1;
40910   arg2 = (unsigned int)jarg2;
40911   arg3 = (Dali::Pixel::Format)jarg3;
40912   {
40913     try {
40914       result = Dali::BufferImage::New(arg1,arg2,arg3);
40915     } catch (std::out_of_range& e) {
40916       {
40917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40918       };
40919     } catch (std::exception& e) {
40920       {
40921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40922       };
40923     } catch (...) {
40924       {
40925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40926       };
40927     }
40928   }
40929   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40930   return jresult;
40931 }
40932
40933
40934 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
40935   void * jresult ;
40936   unsigned int arg1 ;
40937   unsigned int arg2 ;
40938   Dali::BufferImage result;
40939
40940   arg1 = (unsigned int)jarg1;
40941   arg2 = (unsigned int)jarg2;
40942   {
40943     try {
40944       result = Dali::BufferImage::New(arg1,arg2);
40945     } catch (std::out_of_range& e) {
40946       {
40947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40948       };
40949     } catch (std::exception& e) {
40950       {
40951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40952       };
40953     } catch (...) {
40954       {
40955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40956       };
40957     }
40958   }
40959   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40960   return jresult;
40961 }
40962
40963
40964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
40965   void * jresult ;
40966   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40967   unsigned int arg2 ;
40968   unsigned int arg3 ;
40969   Dali::Pixel::Format arg4 ;
40970   unsigned int arg5 ;
40971   Dali::BufferImage result;
40972
40973   arg1 = jarg1;
40974   arg2 = (unsigned int)jarg2;
40975   arg3 = (unsigned int)jarg3;
40976   arg4 = (Dali::Pixel::Format)jarg4;
40977   arg5 = (unsigned int)jarg5;
40978   {
40979     try {
40980       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
40981     } catch (std::out_of_range& e) {
40982       {
40983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40984       };
40985     } catch (std::exception& e) {
40986       {
40987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40988       };
40989     } catch (...) {
40990       {
40991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40992       };
40993     }
40994   }
40995   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40996
40997
40998   return jresult;
40999 }
41000
41001
41002 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41003   void * jresult ;
41004   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41005   unsigned int arg2 ;
41006   unsigned int arg3 ;
41007   Dali::Pixel::Format arg4 ;
41008   Dali::BufferImage result;
41009
41010   arg1 = jarg1;
41011   arg2 = (unsigned int)jarg2;
41012   arg3 = (unsigned int)jarg3;
41013   arg4 = (Dali::Pixel::Format)jarg4;
41014   {
41015     try {
41016       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41017     } catch (std::out_of_range& e) {
41018       {
41019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41020       };
41021     } catch (std::exception& e) {
41022       {
41023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41024       };
41025     } catch (...) {
41026       {
41027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41028       };
41029     }
41030   }
41031   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41032
41033
41034   return jresult;
41035 }
41036
41037
41038 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41039   void * jresult ;
41040   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41041   unsigned int arg2 ;
41042   unsigned int arg3 ;
41043   Dali::BufferImage result;
41044
41045   arg1 = jarg1;
41046   arg2 = (unsigned int)jarg2;
41047   arg3 = (unsigned int)jarg3;
41048   {
41049     try {
41050       result = Dali::BufferImage::New(arg1,arg2,arg3);
41051     } catch (std::out_of_range& e) {
41052       {
41053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41054       };
41055     } catch (std::exception& e) {
41056       {
41057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41058       };
41059     } catch (...) {
41060       {
41061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41062       };
41063     }
41064   }
41065   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41066
41067
41068   return jresult;
41069 }
41070
41071
41072 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_DownCast(void * jarg1) {
41073   void * jresult ;
41074   Dali::BaseHandle arg1 ;
41075   Dali::BaseHandle *argp1 ;
41076   Dali::BufferImage result;
41077
41078   argp1 = (Dali::BaseHandle *)jarg1;
41079   if (!argp1) {
41080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41081     return 0;
41082   }
41083   arg1 = *argp1;
41084   {
41085     try {
41086       result = Dali::BufferImage::DownCast(arg1);
41087     } catch (std::out_of_range& e) {
41088       {
41089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41090       };
41091     } catch (std::exception& e) {
41092       {
41093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41094       };
41095     } catch (...) {
41096       {
41097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41098       };
41099     }
41100   }
41101   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41102   return jresult;
41103 }
41104
41105
41106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BufferImage(void * jarg1) {
41107   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41108
41109   arg1 = (Dali::BufferImage *)jarg1;
41110   {
41111     try {
41112       delete arg1;
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41120       };
41121     } catch (...) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41124       };
41125     }
41126   }
41127 }
41128
41129
41130 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BufferImage__SWIG_1(void * jarg1) {
41131   void * jresult ;
41132   Dali::BufferImage *arg1 = 0 ;
41133   Dali::BufferImage *result = 0 ;
41134
41135   arg1 = (Dali::BufferImage *)jarg1;
41136   if (!arg1) {
41137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41138     return 0;
41139   }
41140   {
41141     try {
41142       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41143     } catch (std::out_of_range& e) {
41144       {
41145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41146       };
41147     } catch (std::exception& e) {
41148       {
41149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (...) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41154       };
41155     }
41156   }
41157   jresult = (void *)result;
41158   return jresult;
41159 }
41160
41161
41162 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_Assign(void * jarg1, void * jarg2) {
41163   void * jresult ;
41164   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41165   Dali::BufferImage *arg2 = 0 ;
41166   Dali::BufferImage *result = 0 ;
41167
41168   arg1 = (Dali::BufferImage *)jarg1;
41169   arg2 = (Dali::BufferImage *)jarg2;
41170   if (!arg2) {
41171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41172     return 0;
41173   }
41174   {
41175     try {
41176       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41177     } catch (std::out_of_range& e) {
41178       {
41179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41180       };
41181     } catch (std::exception& e) {
41182       {
41183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41184       };
41185     } catch (...) {
41186       {
41187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41188       };
41189     }
41190   }
41191   jresult = (void *)result;
41192   return jresult;
41193 }
41194
41195
41196 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_WHITE() {
41197   void * jresult ;
41198   Dali::BufferImage result;
41199
41200   {
41201     try {
41202       result = Dali::BufferImage::WHITE();
41203     } catch (std::out_of_range& e) {
41204       {
41205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (std::exception& e) {
41208       {
41209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41210       };
41211     } catch (...) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41214       };
41215     }
41216   }
41217   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41218   return jresult;
41219 }
41220
41221
41222 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_BufferImage_GetBuffer(void * jarg1) {
41223   void * jresult ;
41224   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41225   Dali::PixelBuffer *result = 0 ;
41226
41227   arg1 = (Dali::BufferImage *)jarg1;
41228   {
41229     try {
41230       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41231     } catch (std::out_of_range& e) {
41232       {
41233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41234       };
41235     } catch (std::exception& e) {
41236       {
41237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41242       };
41243     }
41244   }
41245   jresult = (void *)result;
41246   return jresult;
41247 }
41248
41249
41250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_GetBufferSize(void * jarg1) {
41251   unsigned int jresult ;
41252   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41253   unsigned int result;
41254
41255   arg1 = (Dali::BufferImage *)jarg1;
41256   {
41257     try {
41258       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41259     } catch (std::out_of_range& e) {
41260       {
41261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41262       };
41263     } catch (std::exception& e) {
41264       {
41265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41266       };
41267     } catch (...) {
41268       {
41269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41270       };
41271     }
41272   }
41273   jresult = result;
41274   return jresult;
41275 }
41276
41277
41278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_GetBufferStride(void * jarg1) {
41279   unsigned int jresult ;
41280   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41281   unsigned int result;
41282
41283   arg1 = (Dali::BufferImage *)jarg1;
41284   {
41285     try {
41286       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41287     } catch (std::out_of_range& e) {
41288       {
41289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41290       };
41291     } catch (std::exception& e) {
41292       {
41293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41294       };
41295     } catch (...) {
41296       {
41297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41298       };
41299     }
41300   }
41301   jresult = result;
41302   return jresult;
41303 }
41304
41305
41306 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BufferImage_GetPixelFormat(void * jarg1) {
41307   int jresult ;
41308   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41309   Dali::Pixel::Format result;
41310
41311   arg1 = (Dali::BufferImage *)jarg1;
41312   {
41313     try {
41314       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41315     } catch (std::out_of_range& e) {
41316       {
41317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41318       };
41319     } catch (std::exception& e) {
41320       {
41321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41322       };
41323     } catch (...) {
41324       {
41325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41326       };
41327     }
41328   }
41329   jresult = (int)result;
41330   return jresult;
41331 }
41332
41333
41334 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BufferImage_Update__SWIG_0(void * jarg1) {
41335   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41336
41337   arg1 = (Dali::BufferImage *)jarg1;
41338   {
41339     try {
41340       (arg1)->Update();
41341     } catch (std::out_of_range& e) {
41342       {
41343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41344       };
41345     } catch (std::exception& e) {
41346       {
41347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41352       };
41353     }
41354   }
41355 }
41356
41357
41358 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41359   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41360   Dali::RectArea arg2 ;
41361   Dali::RectArea *argp2 ;
41362
41363   arg1 = (Dali::BufferImage *)jarg1;
41364   argp2 = (Dali::RectArea *)jarg2;
41365   if (!argp2) {
41366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41367     return ;
41368   }
41369   arg2 = *argp2;
41370   {
41371     try {
41372       (arg1)->Update(arg2);
41373     } catch (std::out_of_range& e) {
41374       {
41375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41376       };
41377     } catch (std::exception& e) {
41378       {
41379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41380       };
41381     } catch (...) {
41382       {
41383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41384       };
41385     }
41386   }
41387 }
41388
41389
41390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BufferImage_IsDataExternal(void * jarg1) {
41391   unsigned int jresult ;
41392   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41393   bool result;
41394
41395   arg1 = (Dali::BufferImage *)jarg1;
41396   {
41397     try {
41398       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41399     } catch (std::out_of_range& e) {
41400       {
41401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41402       };
41403     } catch (std::exception& e) {
41404       {
41405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41406       };
41407     } catch (...) {
41408       {
41409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41410       };
41411     }
41412   }
41413   jresult = result;
41414   return jresult;
41415 }
41416
41417
41418 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_EncodedBufferImage__SWIG_0() {
41419   void * jresult ;
41420   Dali::EncodedBufferImage *result = 0 ;
41421
41422   {
41423     try {
41424       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41425     } catch (std::out_of_range& e) {
41426       {
41427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41428       };
41429     } catch (std::exception& e) {
41430       {
41431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (...) {
41434       {
41435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41436       };
41437     }
41438   }
41439   jresult = (void *)result;
41440   return jresult;
41441 }
41442
41443
41444 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41445   void * jresult ;
41446   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41447   std::size_t arg2 ;
41448   Dali::EncodedBufferImage result;
41449
41450   arg1 = (uint8_t *)jarg1;
41451   arg2 = (std::size_t)jarg2;
41452   {
41453     try {
41454       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41455     } catch (std::out_of_range& e) {
41456       {
41457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41458       };
41459     } catch (std::exception& e) {
41460       {
41461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41462       };
41463     } catch (...) {
41464       {
41465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41466       };
41467     }
41468   }
41469   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41470   return jresult;
41471 }
41472
41473
41474 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41475   void * jresult ;
41476   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41477   std::size_t arg2 ;
41478   Dali::ImageDimensions arg3 ;
41479   Dali::FittingMode::Type arg4 ;
41480   Dali::SamplingMode::Type arg5 ;
41481   bool arg6 ;
41482   Dali::ImageDimensions *argp3 ;
41483   Dali::EncodedBufferImage result;
41484
41485   arg1 = (uint8_t *)jarg1;
41486   arg2 = (std::size_t)jarg2;
41487   argp3 = (Dali::ImageDimensions *)jarg3;
41488   if (!argp3) {
41489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41490     return 0;
41491   }
41492   arg3 = *argp3;
41493   arg4 = (Dali::FittingMode::Type)jarg4;
41494   arg5 = (Dali::SamplingMode::Type)jarg5;
41495   arg6 = jarg6 ? true : false;
41496   {
41497     try {
41498       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41499     } catch (std::out_of_range& e) {
41500       {
41501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41502       };
41503     } catch (std::exception& e) {
41504       {
41505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41506       };
41507     } catch (...) {
41508       {
41509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41510       };
41511     }
41512   }
41513   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41514   return jresult;
41515 }
41516
41517
41518 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41519   void * jresult ;
41520   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41521   std::size_t arg2 ;
41522   Dali::ImageDimensions arg3 ;
41523   Dali::FittingMode::Type arg4 ;
41524   Dali::SamplingMode::Type arg5 ;
41525   Dali::ImageDimensions *argp3 ;
41526   Dali::EncodedBufferImage result;
41527
41528   arg1 = (uint8_t *)jarg1;
41529   arg2 = (std::size_t)jarg2;
41530   argp3 = (Dali::ImageDimensions *)jarg3;
41531   if (!argp3) {
41532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41533     return 0;
41534   }
41535   arg3 = *argp3;
41536   arg4 = (Dali::FittingMode::Type)jarg4;
41537   arg5 = (Dali::SamplingMode::Type)jarg5;
41538   {
41539     try {
41540       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41541     } catch (std::out_of_range& e) {
41542       {
41543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41544       };
41545     } catch (std::exception& e) {
41546       {
41547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41548       };
41549     } catch (...) {
41550       {
41551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41552       };
41553     }
41554   }
41555   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41556   return jresult;
41557 }
41558
41559
41560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_DownCast(void * jarg1) {
41561   void * jresult ;
41562   Dali::BaseHandle arg1 ;
41563   Dali::BaseHandle *argp1 ;
41564   Dali::EncodedBufferImage result;
41565
41566   argp1 = (Dali::BaseHandle *)jarg1;
41567   if (!argp1) {
41568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41569     return 0;
41570   }
41571   arg1 = *argp1;
41572   {
41573     try {
41574       result = Dali::EncodedBufferImage::DownCast(arg1);
41575     } catch (std::out_of_range& e) {
41576       {
41577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41578       };
41579     } catch (std::exception& e) {
41580       {
41581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (...) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41586       };
41587     }
41588   }
41589   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41590   return jresult;
41591 }
41592
41593
41594 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_EncodedBufferImage(void * jarg1) {
41595   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41596
41597   arg1 = (Dali::EncodedBufferImage *)jarg1;
41598   {
41599     try {
41600       delete arg1;
41601     } catch (std::out_of_range& e) {
41602       {
41603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41604       };
41605     } catch (std::exception& e) {
41606       {
41607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41608       };
41609     } catch (...) {
41610       {
41611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41612       };
41613     }
41614   }
41615 }
41616
41617
41618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41619   void * jresult ;
41620   Dali::EncodedBufferImage *arg1 = 0 ;
41621   Dali::EncodedBufferImage *result = 0 ;
41622
41623   arg1 = (Dali::EncodedBufferImage *)jarg1;
41624   if (!arg1) {
41625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41626     return 0;
41627   }
41628   {
41629     try {
41630       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41631     } catch (std::out_of_range& e) {
41632       {
41633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41634       };
41635     } catch (std::exception& e) {
41636       {
41637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (...) {
41640       {
41641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41642       };
41643     }
41644   }
41645   jresult = (void *)result;
41646   return jresult;
41647 }
41648
41649
41650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41651   void * jresult ;
41652   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41653   Dali::EncodedBufferImage *arg2 = 0 ;
41654   Dali::EncodedBufferImage *result = 0 ;
41655
41656   arg1 = (Dali::EncodedBufferImage *)jarg1;
41657   arg2 = (Dali::EncodedBufferImage *)jarg2;
41658   if (!arg2) {
41659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41660     return 0;
41661   }
41662   {
41663     try {
41664       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41665     } catch (std::out_of_range& e) {
41666       {
41667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (std::exception& e) {
41670       {
41671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (...) {
41674       {
41675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41676       };
41677     }
41678   }
41679   jresult = (void *)result;
41680   return jresult;
41681 }
41682
41683
41684 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NativeImage__SWIG_0() {
41685   void * jresult ;
41686   Dali::NativeImage *result = 0 ;
41687
41688   {
41689     try {
41690       result = (Dali::NativeImage *)new Dali::NativeImage();
41691     } catch (std::out_of_range& e) {
41692       {
41693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41694       };
41695     } catch (std::exception& e) {
41696       {
41697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (...) {
41700       {
41701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41702       };
41703     }
41704   }
41705   jresult = (void *)result;
41706   return jresult;
41707 }
41708
41709
41710 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_NativeImage(void * jarg1) {
41711   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41712
41713   arg1 = (Dali::NativeImage *)jarg1;
41714   {
41715     try {
41716       delete arg1;
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41724       };
41725     } catch (...) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41728       };
41729     }
41730   }
41731 }
41732
41733
41734 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NativeImage__SWIG_1(void * jarg1) {
41735   void * jresult ;
41736   Dali::NativeImage *arg1 = 0 ;
41737   Dali::NativeImage *result = 0 ;
41738
41739   arg1 = (Dali::NativeImage *)jarg1;
41740   if (!arg1) {
41741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41742     return 0;
41743   }
41744   {
41745     try {
41746       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41747     } catch (std::out_of_range& e) {
41748       {
41749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41750       };
41751     } catch (std::exception& e) {
41752       {
41753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41754       };
41755     } catch (...) {
41756       {
41757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41758       };
41759     }
41760   }
41761   jresult = (void *)result;
41762   return jresult;
41763 }
41764
41765
41766 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_Assign(void * jarg1, void * jarg2) {
41767   void * jresult ;
41768   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41769   Dali::NativeImage *arg2 = 0 ;
41770   Dali::NativeImage *result = 0 ;
41771
41772   arg1 = (Dali::NativeImage *)jarg1;
41773   arg2 = (Dali::NativeImage *)jarg2;
41774   if (!arg2) {
41775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41776     return 0;
41777   }
41778   {
41779     try {
41780       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41781     } catch (std::out_of_range& e) {
41782       {
41783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41784       };
41785     } catch (std::exception& e) {
41786       {
41787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41788       };
41789     } catch (...) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41792       };
41793     }
41794   }
41795   jresult = (void *)result;
41796   return jresult;
41797 }
41798
41799
41800 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImage_CreateGlTexture(void * jarg1) {
41801   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41802
41803   arg1 = (Dali::NativeImage *)jarg1;
41804   {
41805     try {
41806       (arg1)->CreateGlTexture();
41807     } catch (std::out_of_range& e) {
41808       {
41809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41810       };
41811     } catch (std::exception& e) {
41812       {
41813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41814       };
41815     } catch (...) {
41816       {
41817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41818       };
41819     }
41820   }
41821 }
41822
41823
41824 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_New(void * jarg1) {
41825   void * jresult ;
41826   NativeImageInterface *arg1 = 0 ;
41827   Dali::NativeImage result;
41828
41829   arg1 = (NativeImageInterface *)jarg1;
41830   if (!arg1) {
41831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41832     return 0;
41833   }
41834   {
41835     try {
41836       result = Dali::NativeImage::New(*arg1);
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (...) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41848       };
41849     }
41850   }
41851   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NativeImage_DownCast(void * jarg1) {
41857   void * jresult ;
41858   Dali::BaseHandle arg1 ;
41859   Dali::BaseHandle *argp1 ;
41860   Dali::NativeImage result;
41861
41862   argp1 = (Dali::BaseHandle *)jarg1;
41863   if (!argp1) {
41864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41865     return 0;
41866   }
41867   arg1 = *argp1;
41868   {
41869     try {
41870       result = Dali::NativeImage::DownCast(arg1);
41871     } catch (std::out_of_range& e) {
41872       {
41873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41874       };
41875     } catch (std::exception& e) {
41876       {
41877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41878       };
41879     } catch (...) {
41880       {
41881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41882       };
41883     }
41884   }
41885   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41886   return jresult;
41887 }
41888
41889
41890 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
41891   char * jresult ;
41892   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41893   char *result = 0 ;
41894
41895   arg1 = (Dali::NativeImage *)jarg1;
41896   {
41897     try {
41898       result = (char *)(arg1)->GetCustomFragmentPreFix();
41899     } catch (std::out_of_range& e) {
41900       {
41901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (std::exception& e) {
41904       {
41905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41910       };
41911     }
41912   }
41913   jresult = SWIG_csharp_string_callback((const char *)result);
41914   return jresult;
41915 }
41916
41917
41918 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_NativeImage_GetCustomSamplerTypename(void * jarg1) {
41919   char * jresult ;
41920   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41921   char *result = 0 ;
41922
41923   arg1 = (Dali::NativeImage *)jarg1;
41924   {
41925     try {
41926       result = (char *)(arg1)->GetCustomSamplerTypename();
41927     } catch (std::out_of_range& e) {
41928       {
41929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41930       };
41931     } catch (std::exception& e) {
41932       {
41933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41934       };
41935     } catch (...) {
41936       {
41937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41938       };
41939     }
41940   }
41941   jresult = SWIG_csharp_string_callback((const char *)result);
41942   return jresult;
41943 }
41944
41945
41946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GlExtensionCreate(void * jarg1) {
41947   unsigned int jresult ;
41948   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41949   bool result;
41950
41951   arg1 = (Dali::NativeImageInterface *)jarg1;
41952   {
41953     try {
41954       result = (bool)(arg1)->GlExtensionCreate();
41955     } catch (std::out_of_range& e) {
41956       {
41957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41958       };
41959     } catch (std::exception& e) {
41960       {
41961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (...) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41966       };
41967     }
41968   }
41969   jresult = result;
41970   return jresult;
41971 }
41972
41973
41974 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
41975   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41976
41977   arg1 = (Dali::NativeImageInterface *)jarg1;
41978   {
41979     try {
41980       (arg1)->GlExtensionDestroy();
41981     } catch (std::out_of_range& e) {
41982       {
41983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41984       };
41985     } catch (std::exception& e) {
41986       {
41987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41988       };
41989     } catch (...) {
41990       {
41991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41992       };
41993     }
41994   }
41995 }
41996
41997
41998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_TargetTexture(void * jarg1) {
41999   unsigned int jresult ;
42000   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42001   unsigned int result;
42002
42003   arg1 = (Dali::NativeImageInterface *)jarg1;
42004   {
42005     try {
42006       result = (unsigned int)(arg1)->TargetTexture();
42007     } catch (std::out_of_range& e) {
42008       {
42009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (std::exception& e) {
42012       {
42013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42014       };
42015     } catch (...) {
42016       {
42017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42018       };
42019     }
42020   }
42021   jresult = result;
42022   return jresult;
42023 }
42024
42025
42026 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_NativeImageInterface_PrepareTexture(void * jarg1) {
42027   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42028
42029   arg1 = (Dali::NativeImageInterface *)jarg1;
42030   {
42031     try {
42032       (arg1)->PrepareTexture();
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42040       };
42041     } catch (...) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42044       };
42045     }
42046   }
42047 }
42048
42049
42050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GetWidth(void * jarg1) {
42051   unsigned int jresult ;
42052   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42053   unsigned int result;
42054
42055   arg1 = (Dali::NativeImageInterface *)jarg1;
42056   {
42057     try {
42058       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42059     } catch (std::out_of_range& e) {
42060       {
42061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42062       };
42063     } catch (std::exception& e) {
42064       {
42065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42066       };
42067     } catch (...) {
42068       {
42069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42070       };
42071     }
42072   }
42073   jresult = result;
42074   return jresult;
42075 }
42076
42077
42078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_GetHeight(void * jarg1) {
42079   unsigned int jresult ;
42080   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42081   unsigned int result;
42082
42083   arg1 = (Dali::NativeImageInterface *)jarg1;
42084   {
42085     try {
42086       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42087     } catch (std::out_of_range& e) {
42088       {
42089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42090       };
42091     } catch (std::exception& e) {
42092       {
42093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42094       };
42095     } catch (...) {
42096       {
42097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42098       };
42099     }
42100   }
42101   jresult = result;
42102   return jresult;
42103 }
42104
42105
42106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NativeImageInterface_RequiresBlending(void * jarg1) {
42107   unsigned int jresult ;
42108   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42109   bool result;
42110
42111   arg1 = (Dali::NativeImageInterface *)jarg1;
42112   {
42113     try {
42114       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42115     } catch (std::out_of_range& e) {
42116       {
42117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42118       };
42119     } catch (std::exception& e) {
42120       {
42121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42122       };
42123     } catch (...) {
42124       {
42125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42126       };
42127     }
42128   }
42129   jresult = result;
42130   return jresult;
42131 }
42132
42133
42134 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_GetImageSize(char * jarg1) {
42135   void * jresult ;
42136   std::string *arg1 = 0 ;
42137   Dali::ImageDimensions result;
42138
42139   if (!jarg1) {
42140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42141     return 0;
42142   }
42143   std::string arg1_str(jarg1);
42144   arg1 = &arg1_str;
42145   {
42146     try {
42147       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42148     } catch (std::out_of_range& e) {
42149       {
42150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42151       };
42152     } catch (std::exception& e) {
42153       {
42154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42155       };
42156     } catch (...) {
42157       {
42158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42159       };
42160     }
42161   }
42162   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42163
42164   //argout typemap for const std::string&
42165
42166   return jresult;
42167 }
42168
42169
42170 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImage__SWIG_0() {
42171   void * jresult ;
42172   Dali::ResourceImage *result = 0 ;
42173
42174   {
42175     try {
42176       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42177     } catch (std::out_of_range& e) {
42178       {
42179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42180       };
42181     } catch (std::exception& e) {
42182       {
42183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42184       };
42185     } catch (...) {
42186       {
42187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42188       };
42189     }
42190   }
42191   jresult = (void *)result;
42192   return jresult;
42193 }
42194
42195
42196 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ResourceImage(void * jarg1) {
42197   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42198
42199   arg1 = (Dali::ResourceImage *)jarg1;
42200   {
42201     try {
42202       delete arg1;
42203     } catch (std::out_of_range& e) {
42204       {
42205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42206       };
42207     } catch (std::exception& e) {
42208       {
42209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42210       };
42211     } catch (...) {
42212       {
42213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42214       };
42215     }
42216   }
42217 }
42218
42219
42220 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImage__SWIG_1(void * jarg1) {
42221   void * jresult ;
42222   Dali::ResourceImage *arg1 = 0 ;
42223   Dali::ResourceImage *result = 0 ;
42224
42225   arg1 = (Dali::ResourceImage *)jarg1;
42226   if (!arg1) {
42227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42228     return 0;
42229   }
42230   {
42231     try {
42232       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42244       };
42245     }
42246   }
42247   jresult = (void *)result;
42248   return jresult;
42249 }
42250
42251
42252 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_Assign(void * jarg1, void * jarg2) {
42253   void * jresult ;
42254   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42255   Dali::ResourceImage *arg2 = 0 ;
42256   Dali::ResourceImage *result = 0 ;
42257
42258   arg1 = (Dali::ResourceImage *)jarg1;
42259   arg2 = (Dali::ResourceImage *)jarg2;
42260   if (!arg2) {
42261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42262     return 0;
42263   }
42264   {
42265     try {
42266       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42267     } catch (std::out_of_range& e) {
42268       {
42269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42270       };
42271     } catch (std::exception& e) {
42272       {
42273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42274       };
42275     } catch (...) {
42276       {
42277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42278       };
42279     }
42280   }
42281   jresult = (void *)result;
42282   return jresult;
42283 }
42284
42285
42286 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42287   void * jresult ;
42288   std::string *arg1 = 0 ;
42289   bool arg2 ;
42290   Dali::ResourceImage result;
42291
42292   if (!jarg1) {
42293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42294     return 0;
42295   }
42296   std::string arg1_str(jarg1);
42297   arg1 = &arg1_str;
42298   arg2 = jarg2 ? true : false;
42299   {
42300     try {
42301       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42302     } catch (std::out_of_range& e) {
42303       {
42304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42305       };
42306     } catch (std::exception& e) {
42307       {
42308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42309       };
42310     } catch (...) {
42311       {
42312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42313       };
42314     }
42315   }
42316   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42317
42318   //argout typemap for const std::string&
42319
42320   return jresult;
42321 }
42322
42323
42324 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_1(char * jarg1) {
42325   void * jresult ;
42326   std::string *arg1 = 0 ;
42327   Dali::ResourceImage result;
42328
42329   if (!jarg1) {
42330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42331     return 0;
42332   }
42333   std::string arg1_str(jarg1);
42334   arg1 = &arg1_str;
42335   {
42336     try {
42337       result = Dali::ResourceImage::New((std::string const &)*arg1);
42338     } catch (std::out_of_range& e) {
42339       {
42340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42341       };
42342     } catch (std::exception& e) {
42343       {
42344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42345       };
42346     } catch (...) {
42347       {
42348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42349       };
42350     }
42351   }
42352   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42353
42354   //argout typemap for const std::string&
42355
42356   return jresult;
42357 }
42358
42359
42360 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42361   void * jresult ;
42362   std::string *arg1 = 0 ;
42363   Dali::ImageDimensions arg2 ;
42364   Dali::FittingMode::Type arg3 ;
42365   Dali::SamplingMode::Type arg4 ;
42366   bool arg5 ;
42367   Dali::ImageDimensions *argp2 ;
42368   Dali::ResourceImage result;
42369
42370   if (!jarg1) {
42371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42372     return 0;
42373   }
42374   std::string arg1_str(jarg1);
42375   arg1 = &arg1_str;
42376   argp2 = (Dali::ImageDimensions *)jarg2;
42377   if (!argp2) {
42378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42379     return 0;
42380   }
42381   arg2 = *argp2;
42382   arg3 = (Dali::FittingMode::Type)jarg3;
42383   arg4 = (Dali::SamplingMode::Type)jarg4;
42384   arg5 = jarg5 ? true : false;
42385   {
42386     try {
42387       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42388     } catch (std::out_of_range& e) {
42389       {
42390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42391       };
42392     } catch (std::exception& e) {
42393       {
42394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42395       };
42396     } catch (...) {
42397       {
42398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42399       };
42400     }
42401   }
42402   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42403
42404   //argout typemap for const std::string&
42405
42406   return jresult;
42407 }
42408
42409
42410 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42411   void * jresult ;
42412   std::string *arg1 = 0 ;
42413   Dali::ImageDimensions arg2 ;
42414   Dali::FittingMode::Type arg3 ;
42415   Dali::SamplingMode::Type arg4 ;
42416   Dali::ImageDimensions *argp2 ;
42417   Dali::ResourceImage result;
42418
42419   if (!jarg1) {
42420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42421     return 0;
42422   }
42423   std::string arg1_str(jarg1);
42424   arg1 = &arg1_str;
42425   argp2 = (Dali::ImageDimensions *)jarg2;
42426   if (!argp2) {
42427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42428     return 0;
42429   }
42430   arg2 = *argp2;
42431   arg3 = (Dali::FittingMode::Type)jarg3;
42432   arg4 = (Dali::SamplingMode::Type)jarg4;
42433   {
42434     try {
42435       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42436     } catch (std::out_of_range& e) {
42437       {
42438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42439       };
42440     } catch (std::exception& e) {
42441       {
42442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42443       };
42444     } catch (...) {
42445       {
42446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42447       };
42448     }
42449   }
42450   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42451
42452   //argout typemap for const std::string&
42453
42454   return jresult;
42455 }
42456
42457
42458 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42459   void * jresult ;
42460   std::string *arg1 = 0 ;
42461   Dali::ImageDimensions arg2 ;
42462   Dali::FittingMode::Type arg3 ;
42463   Dali::ImageDimensions *argp2 ;
42464   Dali::ResourceImage result;
42465
42466   if (!jarg1) {
42467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42468     return 0;
42469   }
42470   std::string arg1_str(jarg1);
42471   arg1 = &arg1_str;
42472   argp2 = (Dali::ImageDimensions *)jarg2;
42473   if (!argp2) {
42474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42475     return 0;
42476   }
42477   arg2 = *argp2;
42478   arg3 = (Dali::FittingMode::Type)jarg3;
42479   {
42480     try {
42481       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42482     } catch (std::out_of_range& e) {
42483       {
42484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42485       };
42486     } catch (std::exception& e) {
42487       {
42488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (...) {
42491       {
42492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42493       };
42494     }
42495   }
42496   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42497
42498   //argout typemap for const std::string&
42499
42500   return jresult;
42501 }
42502
42503
42504 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42505   void * jresult ;
42506   std::string *arg1 = 0 ;
42507   Dali::ImageDimensions arg2 ;
42508   Dali::ImageDimensions *argp2 ;
42509   Dali::ResourceImage result;
42510
42511   if (!jarg1) {
42512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42513     return 0;
42514   }
42515   std::string arg1_str(jarg1);
42516   arg1 = &arg1_str;
42517   argp2 = (Dali::ImageDimensions *)jarg2;
42518   if (!argp2) {
42519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42520     return 0;
42521   }
42522   arg2 = *argp2;
42523   {
42524     try {
42525       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42526     } catch (std::out_of_range& e) {
42527       {
42528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42529       };
42530     } catch (std::exception& e) {
42531       {
42532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42533       };
42534     } catch (...) {
42535       {
42536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42537       };
42538     }
42539   }
42540   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42541
42542   //argout typemap for const std::string&
42543
42544   return jresult;
42545 }
42546
42547
42548 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_DownCast(void * jarg1) {
42549   void * jresult ;
42550   Dali::BaseHandle arg1 ;
42551   Dali::BaseHandle *argp1 ;
42552   Dali::ResourceImage result;
42553
42554   argp1 = (Dali::BaseHandle *)jarg1;
42555   if (!argp1) {
42556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42557     return 0;
42558   }
42559   arg1 = *argp1;
42560   {
42561     try {
42562       result = Dali::ResourceImage::DownCast(arg1);
42563     } catch (std::out_of_range& e) {
42564       {
42565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42566       };
42567     } catch (std::exception& e) {
42568       {
42569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42574       };
42575     }
42576   }
42577   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ResourceImage_GetLoadingState(void * jarg1) {
42583   int jresult ;
42584   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42585   Dali::LoadingState result;
42586
42587   arg1 = (Dali::ResourceImage *)jarg1;
42588   {
42589     try {
42590       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42591     } catch (std::out_of_range& e) {
42592       {
42593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (std::exception& e) {
42596       {
42597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42602       };
42603     }
42604   }
42605   jresult = (int)result;
42606   return jresult;
42607 }
42608
42609
42610 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_ResourceImage_GetUrl(void * jarg1) {
42611   char * jresult ;
42612   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42613   std::string result;
42614
42615   arg1 = (Dali::ResourceImage *)jarg1;
42616   {
42617     try {
42618       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42619     } catch (std::out_of_range& e) {
42620       {
42621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (std::exception& e) {
42624       {
42625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42626       };
42627     } catch (...) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42630       };
42631     }
42632   }
42633   jresult = SWIG_csharp_string_callback((&result)->c_str());
42634   return jresult;
42635 }
42636
42637
42638 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImage_Reload(void * jarg1) {
42639   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42640
42641   arg1 = (Dali::ResourceImage *)jarg1;
42642   {
42643     try {
42644       (arg1)->Reload();
42645     } catch (std::out_of_range& e) {
42646       {
42647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42648       };
42649     } catch (std::exception& e) {
42650       {
42651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42652       };
42653     } catch (...) {
42654       {
42655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42656       };
42657     }
42658   }
42659 }
42660
42661
42662 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42663   void * jresult ;
42664   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42665   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42666
42667   arg1 = (Dali::ResourceImage *)jarg1;
42668   {
42669     try {
42670       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42671     } catch (std::out_of_range& e) {
42672       {
42673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (std::exception& e) {
42676       {
42677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBufferImage__SWIG_0() {
42691   void * jresult ;
42692   Dali::FrameBufferImage *result = 0 ;
42693
42694   {
42695     try {
42696       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42704       };
42705     } catch (...) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42708       };
42709     }
42710   }
42711   jresult = (void *)result;
42712   return jresult;
42713 }
42714
42715
42716 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42717   void * jresult ;
42718   unsigned int arg1 ;
42719   unsigned int arg2 ;
42720   Dali::Pixel::Format arg3 ;
42721   Dali::RenderBuffer::Format arg4 ;
42722   Dali::FrameBufferImage result;
42723
42724   arg1 = (unsigned int)jarg1;
42725   arg2 = (unsigned int)jarg2;
42726   arg3 = (Dali::Pixel::Format)jarg3;
42727   arg4 = (Dali::RenderBuffer::Format)jarg4;
42728   {
42729     try {
42730       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42731     } catch (std::out_of_range& e) {
42732       {
42733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42734       };
42735     } catch (std::exception& e) {
42736       {
42737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42738       };
42739     } catch (...) {
42740       {
42741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42742       };
42743     }
42744   }
42745   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42746   return jresult;
42747 }
42748
42749
42750 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42751   void * jresult ;
42752   unsigned int arg1 ;
42753   unsigned int arg2 ;
42754   Dali::Pixel::Format arg3 ;
42755   Dali::FrameBufferImage result;
42756
42757   arg1 = (unsigned int)jarg1;
42758   arg2 = (unsigned int)jarg2;
42759   arg3 = (Dali::Pixel::Format)jarg3;
42760   {
42761     try {
42762       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42763     } catch (std::out_of_range& e) {
42764       {
42765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42766       };
42767     } catch (std::exception& e) {
42768       {
42769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42770       };
42771     } catch (...) {
42772       {
42773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42774       };
42775     }
42776   }
42777   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42778   return jresult;
42779 }
42780
42781
42782 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42783   void * jresult ;
42784   unsigned int arg1 ;
42785   unsigned int arg2 ;
42786   Dali::FrameBufferImage result;
42787
42788   arg1 = (unsigned int)jarg1;
42789   arg2 = (unsigned int)jarg2;
42790   {
42791     try {
42792       result = Dali::FrameBufferImage::New(arg1,arg2);
42793     } catch (std::out_of_range& e) {
42794       {
42795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (std::exception& e) {
42798       {
42799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42800       };
42801     } catch (...) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42804       };
42805     }
42806   }
42807   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42808   return jresult;
42809 }
42810
42811
42812 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42813   void * jresult ;
42814   unsigned int arg1 ;
42815   Dali::FrameBufferImage result;
42816
42817   arg1 = (unsigned int)jarg1;
42818   {
42819     try {
42820       result = Dali::FrameBufferImage::New(arg1);
42821     } catch (std::out_of_range& e) {
42822       {
42823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42824       };
42825     } catch (std::exception& e) {
42826       {
42827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42828       };
42829     } catch (...) {
42830       {
42831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42832       };
42833     }
42834   }
42835   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42836   return jresult;
42837 }
42838
42839
42840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_4() {
42841   void * jresult ;
42842   Dali::FrameBufferImage result;
42843
42844   {
42845     try {
42846       result = Dali::FrameBufferImage::New();
42847     } catch (std::out_of_range& e) {
42848       {
42849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42850       };
42851     } catch (std::exception& e) {
42852       {
42853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (...) {
42856       {
42857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42858       };
42859     }
42860   }
42861   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42862   return jresult;
42863 }
42864
42865
42866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_New__SWIG_5(void * jarg1) {
42867   void * jresult ;
42868   Dali::NativeImageInterface *arg1 = 0 ;
42869   Dali::FrameBufferImage result;
42870
42871   arg1 = (Dali::NativeImageInterface *)jarg1;
42872   if (!arg1) {
42873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
42874     return 0;
42875   }
42876   {
42877     try {
42878       result = Dali::FrameBufferImage::New(*arg1);
42879     } catch (std::out_of_range& e) {
42880       {
42881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42882       };
42883     } catch (std::exception& e) {
42884       {
42885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42886       };
42887     } catch (...) {
42888       {
42889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42890       };
42891     }
42892   }
42893   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42894   return jresult;
42895 }
42896
42897
42898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_DownCast(void * jarg1) {
42899   void * jresult ;
42900   Dali::BaseHandle arg1 ;
42901   Dali::BaseHandle *argp1 ;
42902   Dali::FrameBufferImage result;
42903
42904   argp1 = (Dali::BaseHandle *)jarg1;
42905   if (!argp1) {
42906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42907     return 0;
42908   }
42909   arg1 = *argp1;
42910   {
42911     try {
42912       result = Dali::FrameBufferImage::DownCast(arg1);
42913     } catch (std::out_of_range& e) {
42914       {
42915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42916       };
42917     } catch (std::exception& e) {
42918       {
42919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42920       };
42921     } catch (...) {
42922       {
42923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42924       };
42925     }
42926   }
42927   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42928   return jresult;
42929 }
42930
42931
42932 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FrameBufferImage(void * jarg1) {
42933   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42934
42935   arg1 = (Dali::FrameBufferImage *)jarg1;
42936   {
42937     try {
42938       delete arg1;
42939     } catch (std::out_of_range& e) {
42940       {
42941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42942       };
42943     } catch (std::exception& e) {
42944       {
42945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42950       };
42951     }
42952   }
42953 }
42954
42955
42956 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FrameBufferImage__SWIG_1(void * jarg1) {
42957   void * jresult ;
42958   Dali::FrameBufferImage *arg1 = 0 ;
42959   Dali::FrameBufferImage *result = 0 ;
42960
42961   arg1 = (Dali::FrameBufferImage *)jarg1;
42962   if (!arg1) {
42963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42964     return 0;
42965   }
42966   {
42967     try {
42968       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
42969     } catch (std::out_of_range& e) {
42970       {
42971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (std::exception& e) {
42974       {
42975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (...) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42980       };
42981     }
42982   }
42983   jresult = (void *)result;
42984   return jresult;
42985 }
42986
42987
42988 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
42989   void * jresult ;
42990   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42991   Dali::FrameBufferImage *arg2 = 0 ;
42992   Dali::FrameBufferImage *result = 0 ;
42993
42994   arg1 = (Dali::FrameBufferImage *)jarg1;
42995   arg2 = (Dali::FrameBufferImage *)jarg2;
42996   if (!arg2) {
42997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42998     return 0;
42999   }
43000   {
43001     try {
43002       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43003     } catch (std::out_of_range& e) {
43004       {
43005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43006       };
43007     } catch (std::exception& e) {
43008       {
43009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43010       };
43011     } catch (...) {
43012       {
43013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43014       };
43015     }
43016   }
43017   jresult = (void *)result;
43018   return jresult;
43019 }
43020
43021
43022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NinePatchImage__SWIG_0() {
43023   void * jresult ;
43024   Dali::NinePatchImage *result = 0 ;
43025
43026   {
43027     try {
43028       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (void *)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_New(char * jarg1) {
43049   void * jresult ;
43050   std::string *arg1 = 0 ;
43051   Dali::NinePatchImage result;
43052
43053   if (!jarg1) {
43054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43055     return 0;
43056   }
43057   std::string arg1_str(jarg1);
43058   arg1 = &arg1_str;
43059   {
43060     try {
43061       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43062     } catch (std::out_of_range& e) {
43063       {
43064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43065       };
43066     } catch (std::exception& e) {
43067       {
43068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43069       };
43070     } catch (...) {
43071       {
43072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43073       };
43074     }
43075   }
43076   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43077
43078   //argout typemap for const std::string&
43079
43080   return jresult;
43081 }
43082
43083
43084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_DownCast(void * jarg1) {
43085   void * jresult ;
43086   Dali::BaseHandle arg1 ;
43087   Dali::BaseHandle *argp1 ;
43088   Dali::NinePatchImage result;
43089
43090   argp1 = (Dali::BaseHandle *)jarg1;
43091   if (!argp1) {
43092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43093     return 0;
43094   }
43095   arg1 = *argp1;
43096   {
43097     try {
43098       result = Dali::NinePatchImage::DownCast(arg1);
43099     } catch (std::out_of_range& e) {
43100       {
43101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43102       };
43103     } catch (std::exception& e) {
43104       {
43105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43106       };
43107     } catch (...) {
43108       {
43109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43110       };
43111     }
43112   }
43113   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43114   return jresult;
43115 }
43116
43117
43118 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_NinePatchImage(void * jarg1) {
43119   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43120
43121   arg1 = (Dali::NinePatchImage *)jarg1;
43122   {
43123     try {
43124       delete arg1;
43125     } catch (std::out_of_range& e) {
43126       {
43127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43128       };
43129     } catch (std::exception& e) {
43130       {
43131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43132       };
43133     } catch (...) {
43134       {
43135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43136       };
43137     }
43138   }
43139 }
43140
43141
43142 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_NinePatchImage__SWIG_1(void * jarg1) {
43143   void * jresult ;
43144   Dali::NinePatchImage *arg1 = 0 ;
43145   Dali::NinePatchImage *result = 0 ;
43146
43147   arg1 = (Dali::NinePatchImage *)jarg1;
43148   if (!arg1) {
43149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43150     return 0;
43151   }
43152   {
43153     try {
43154       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43155     } catch (std::out_of_range& e) {
43156       {
43157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (std::exception& e) {
43160       {
43161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43166       };
43167     }
43168   }
43169   jresult = (void *)result;
43170   return jresult;
43171 }
43172
43173
43174 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43175   void * jresult ;
43176   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43177   Dali::NinePatchImage *arg2 = 0 ;
43178   Dali::NinePatchImage *result = 0 ;
43179
43180   arg1 = (Dali::NinePatchImage *)jarg1;
43181   arg2 = (Dali::NinePatchImage *)jarg2;
43182   if (!arg2) {
43183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43184     return 0;
43185   }
43186   {
43187     try {
43188       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43189     } catch (std::out_of_range& e) {
43190       {
43191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (std::exception& e) {
43194       {
43195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43200       };
43201     }
43202   }
43203   jresult = (void *)result;
43204   return jresult;
43205 }
43206
43207
43208 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchBorders(void * jarg1) {
43209   void * jresult ;
43210   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43211   Dali::Vector4 result;
43212
43213   arg1 = (Dali::NinePatchImage *)jarg1;
43214   {
43215     try {
43216       result = (arg1)->GetStretchBorders();
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43232   return jresult;
43233 }
43234
43235
43236 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43237   void * jresult ;
43238   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43239   Dali::NinePatchImage::StretchRanges *result = 0 ;
43240
43241   arg1 = (Dali::NinePatchImage *)jarg1;
43242   {
43243     try {
43244       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43245     } catch (std::out_of_range& e) {
43246       {
43247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43248       };
43249     } catch (std::exception& e) {
43250       {
43251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43252       };
43253     } catch (...) {
43254       {
43255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43256       };
43257     }
43258   }
43259   jresult = (void *)result;
43260   return jresult;
43261 }
43262
43263
43264 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43265   void * jresult ;
43266   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43267   Dali::NinePatchImage::StretchRanges *result = 0 ;
43268
43269   arg1 = (Dali::NinePatchImage *)jarg1;
43270   {
43271     try {
43272       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43273     } catch (std::out_of_range& e) {
43274       {
43275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43276       };
43277     } catch (std::exception& e) {
43278       {
43279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43280       };
43281     } catch (...) {
43282       {
43283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43284       };
43285     }
43286   }
43287   jresult = (void *)result;
43288   return jresult;
43289 }
43290
43291
43292 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_GetChildRectangle(void * jarg1) {
43293   void * jresult ;
43294   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43295   Dali::Rect< int > result;
43296
43297   arg1 = (Dali::NinePatchImage *)jarg1;
43298   {
43299     try {
43300       result = (arg1)->GetChildRectangle();
43301     } catch (std::out_of_range& e) {
43302       {
43303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43304       };
43305     } catch (std::exception& e) {
43306       {
43307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43308       };
43309     } catch (...) {
43310       {
43311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43312       };
43313     }
43314   }
43315   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43316   return jresult;
43317 }
43318
43319
43320 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43321   void * jresult ;
43322   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43323   Dali::BufferImage result;
43324
43325   arg1 = (Dali::NinePatchImage *)jarg1;
43326   {
43327     try {
43328       result = (arg1)->CreateCroppedBufferImage();
43329     } catch (std::out_of_range& e) {
43330       {
43331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43332       };
43333     } catch (std::exception& e) {
43334       {
43335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43336       };
43337     } catch (...) {
43338       {
43339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43340       };
43341     }
43342   }
43343   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43344   return jresult;
43345 }
43346
43347
43348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43349   unsigned int jresult ;
43350   std::string *arg1 = 0 ;
43351   bool result;
43352
43353   if (!jarg1) {
43354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43355     return 0;
43356   }
43357   std::string arg1_str(jarg1);
43358   arg1 = &arg1_str;
43359   {
43360     try {
43361       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43362     } catch (std::out_of_range& e) {
43363       {
43364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43365       };
43366     } catch (std::exception& e) {
43367       {
43368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43369       };
43370     } catch (...) {
43371       {
43372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43373       };
43374     }
43375   }
43376   jresult = result;
43377
43378   //argout typemap for const std::string&
43379
43380   return jresult;
43381 }
43382
43383
43384 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TYPE_get() {
43385   int jresult ;
43386   int result;
43387
43388   result = (int)Dali::CameraActor::Property::TYPE;
43389   jresult = (int)result;
43390   return jresult;
43391 }
43392
43393
43394 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_PROJECTION_MODE_get() {
43395   int jresult ;
43396   int result;
43397
43398   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43399   jresult = (int)result;
43400   return jresult;
43401 }
43402
43403
43404 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_FIELD_OF_VIEW_get() {
43405   int jresult ;
43406   int result;
43407
43408   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43409   jresult = (int)result;
43410   return jresult;
43411 }
43412
43413
43414 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_ASPECT_RATIO_get() {
43415   int jresult ;
43416   int result;
43417
43418   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43419   jresult = (int)result;
43420   return jresult;
43421 }
43422
43423
43424 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43425   int jresult ;
43426   int result;
43427
43428   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43429   jresult = (int)result;
43430   return jresult;
43431 }
43432
43433
43434 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43435   int jresult ;
43436   int result;
43437
43438   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43439   jresult = (int)result;
43440   return jresult;
43441 }
43442
43443
43444 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43445   int jresult ;
43446   int result;
43447
43448   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43449   jresult = (int)result;
43450   return jresult;
43451 }
43452
43453
43454 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43455   int jresult ;
43456   int result;
43457
43458   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43459   jresult = (int)result;
43460   return jresult;
43461 }
43462
43463
43464 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43465   int jresult ;
43466   int result;
43467
43468   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43469   jresult = (int)result;
43470   return jresult;
43471 }
43472
43473
43474 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43475   int jresult ;
43476   int result;
43477
43478   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43479   jresult = (int)result;
43480   return jresult;
43481 }
43482
43483
43484 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_TARGET_POSITION_get() {
43485   int jresult ;
43486   int result;
43487
43488   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43489   jresult = (int)result;
43490   return jresult;
43491 }
43492
43493
43494 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_PROJECTION_MATRIX_get() {
43495   int jresult ;
43496   int result;
43497
43498   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43499   jresult = (int)result;
43500   return jresult;
43501 }
43502
43503
43504 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_VIEW_MATRIX_get() {
43505   int jresult ;
43506   int result;
43507
43508   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43509   jresult = (int)result;
43510   return jresult;
43511 }
43512
43513
43514 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_Property_INVERT_Y_AXIS_get() {
43515   int jresult ;
43516   int result;
43517
43518   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43519   jresult = (int)result;
43520   return jresult;
43521 }
43522
43523
43524 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor_Property() {
43525   void * jresult ;
43526   Dali::CameraActor::Property *result = 0 ;
43527
43528   {
43529     try {
43530       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43531     } catch (std::out_of_range& e) {
43532       {
43533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43534       };
43535     } catch (std::exception& e) {
43536       {
43537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43538       };
43539     } catch (...) {
43540       {
43541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43542       };
43543     }
43544   }
43545   jresult = (void *)result;
43546   return jresult;
43547 }
43548
43549
43550 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CameraActor_Property(void * jarg1) {
43551   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43552
43553   arg1 = (Dali::CameraActor::Property *)jarg1;
43554   {
43555     try {
43556       delete arg1;
43557     } catch (std::out_of_range& e) {
43558       {
43559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43560       };
43561     } catch (std::exception& e) {
43562       {
43563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43564       };
43565     } catch (...) {
43566       {
43567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43568       };
43569     }
43570   }
43571 }
43572
43573
43574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor__SWIG_0() {
43575   void * jresult ;
43576   Dali::CameraActor *result = 0 ;
43577
43578   {
43579     try {
43580       result = (Dali::CameraActor *)new Dali::CameraActor();
43581     } catch (std::out_of_range& e) {
43582       {
43583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43584       };
43585     } catch (std::exception& e) {
43586       {
43587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43588       };
43589     } catch (...) {
43590       {
43591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43592       };
43593     }
43594   }
43595   jresult = (void *)result;
43596   return jresult;
43597 }
43598
43599
43600 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_New__SWIG_0() {
43601   void * jresult ;
43602   Dali::CameraActor result;
43603
43604   {
43605     try {
43606       result = Dali::CameraActor::New();
43607     } catch (std::out_of_range& e) {
43608       {
43609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43610       };
43611     } catch (std::exception& e) {
43612       {
43613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43614       };
43615     } catch (...) {
43616       {
43617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43618       };
43619     }
43620   }
43621   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43622   return jresult;
43623 }
43624
43625
43626 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_New__SWIG_1(void * jarg1) {
43627   void * jresult ;
43628   Dali::Size *arg1 = 0 ;
43629   Dali::CameraActor result;
43630
43631   arg1 = (Dali::Size *)jarg1;
43632   if (!arg1) {
43633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43634     return 0;
43635   }
43636   {
43637     try {
43638       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43639     } catch (std::out_of_range& e) {
43640       {
43641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43642       };
43643     } catch (std::exception& e) {
43644       {
43645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43646       };
43647     } catch (...) {
43648       {
43649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43650       };
43651     }
43652   }
43653   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43654   return jresult;
43655 }
43656
43657
43658 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_DownCast(void * jarg1) {
43659   void * jresult ;
43660   Dali::BaseHandle arg1 ;
43661   Dali::BaseHandle *argp1 ;
43662   Dali::CameraActor result;
43663
43664   argp1 = (Dali::BaseHandle *)jarg1;
43665   if (!argp1) {
43666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43667     return 0;
43668   }
43669   arg1 = *argp1;
43670   {
43671     try {
43672       result = Dali::CameraActor::DownCast(arg1);
43673     } catch (std::out_of_range& e) {
43674       {
43675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43676       };
43677     } catch (std::exception& e) {
43678       {
43679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43680       };
43681     } catch (...) {
43682       {
43683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43684       };
43685     }
43686   }
43687   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43688   return jresult;
43689 }
43690
43691
43692 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CameraActor(void * jarg1) {
43693   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43694
43695   arg1 = (Dali::CameraActor *)jarg1;
43696   {
43697     try {
43698       delete arg1;
43699     } catch (std::out_of_range& e) {
43700       {
43701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43702       };
43703     } catch (std::exception& e) {
43704       {
43705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43706       };
43707     } catch (...) {
43708       {
43709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43710       };
43711     }
43712   }
43713 }
43714
43715
43716 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CameraActor__SWIG_1(void * jarg1) {
43717   void * jresult ;
43718   Dali::CameraActor *arg1 = 0 ;
43719   Dali::CameraActor *result = 0 ;
43720
43721   arg1 = (Dali::CameraActor *)jarg1;
43722   if (!arg1) {
43723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43724     return 0;
43725   }
43726   {
43727     try {
43728       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43736       };
43737     } catch (...) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43740       };
43741     }
43742   }
43743   jresult = (void *)result;
43744   return jresult;
43745 }
43746
43747
43748 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_Assign(void * jarg1, void * jarg2) {
43749   void * jresult ;
43750   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43751   Dali::CameraActor *arg2 = 0 ;
43752   Dali::CameraActor *result = 0 ;
43753
43754   arg1 = (Dali::CameraActor *)jarg1;
43755   arg2 = (Dali::CameraActor *)jarg2;
43756   if (!arg2) {
43757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43758     return 0;
43759   }
43760   {
43761     try {
43762       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43763     } catch (std::out_of_range& e) {
43764       {
43765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43766       };
43767     } catch (std::exception& e) {
43768       {
43769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43770       };
43771     } catch (...) {
43772       {
43773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43774       };
43775     }
43776   }
43777   jresult = (void *)result;
43778   return jresult;
43779 }
43780
43781
43782 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetType(void * jarg1, int jarg2) {
43783   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43784   Dali::Camera::Type arg2 ;
43785
43786   arg1 = (Dali::CameraActor *)jarg1;
43787   arg2 = (Dali::Camera::Type)jarg2;
43788   {
43789     try {
43790       (arg1)->SetType(arg2);
43791     } catch (std::out_of_range& e) {
43792       {
43793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43794       };
43795     } catch (std::exception& e) {
43796       {
43797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43798       };
43799     } catch (...) {
43800       {
43801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43802       };
43803     }
43804   }
43805 }
43806
43807
43808 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_GetType(void * jarg1) {
43809   int jresult ;
43810   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43811   Dali::Camera::Type result;
43812
43813   arg1 = (Dali::CameraActor *)jarg1;
43814   {
43815     try {
43816       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43817     } catch (std::out_of_range& e) {
43818       {
43819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43820       };
43821     } catch (std::exception& e) {
43822       {
43823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43824       };
43825     } catch (...) {
43826       {
43827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43828       };
43829     }
43830   }
43831   jresult = (int)result;
43832   return jresult;
43833 }
43834
43835
43836 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43837   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43838   Dali::Camera::ProjectionMode arg2 ;
43839
43840   arg1 = (Dali::CameraActor *)jarg1;
43841   arg2 = (Dali::Camera::ProjectionMode)jarg2;
43842   {
43843     try {
43844       (arg1)->SetProjectionMode(arg2);
43845     } catch (std::out_of_range& e) {
43846       {
43847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43848       };
43849     } catch (std::exception& e) {
43850       {
43851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43852       };
43853     } catch (...) {
43854       {
43855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43856       };
43857     }
43858   }
43859 }
43860
43861
43862 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CameraActor_GetProjectionMode(void * jarg1) {
43863   int jresult ;
43864   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43865   Dali::Camera::ProjectionMode result;
43866
43867   arg1 = (Dali::CameraActor *)jarg1;
43868   {
43869     try {
43870       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
43871     } catch (std::out_of_range& e) {
43872       {
43873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43874       };
43875     } catch (std::exception& e) {
43876       {
43877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43878       };
43879     } catch (...) {
43880       {
43881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43882       };
43883     }
43884   }
43885   jresult = (int)result;
43886   return jresult;
43887 }
43888
43889
43890 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
43891   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43892   float arg2 ;
43893
43894   arg1 = (Dali::CameraActor *)jarg1;
43895   arg2 = (float)jarg2;
43896   {
43897     try {
43898       (arg1)->SetFieldOfView(arg2);
43899     } catch (std::out_of_range& e) {
43900       {
43901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43902       };
43903     } catch (std::exception& e) {
43904       {
43905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43906       };
43907     } catch (...) {
43908       {
43909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43910       };
43911     }
43912   }
43913 }
43914
43915
43916 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetFieldOfView(void * jarg1) {
43917   float jresult ;
43918   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43919   float result;
43920
43921   arg1 = (Dali::CameraActor *)jarg1;
43922   {
43923     try {
43924       result = (float)(arg1)->GetFieldOfView();
43925     } catch (std::out_of_range& e) {
43926       {
43927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43928       };
43929     } catch (std::exception& e) {
43930       {
43931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43932       };
43933     } catch (...) {
43934       {
43935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43936       };
43937     }
43938   }
43939   jresult = result;
43940   return jresult;
43941 }
43942
43943
43944 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
43945   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43946   float arg2 ;
43947
43948   arg1 = (Dali::CameraActor *)jarg1;
43949   arg2 = (float)jarg2;
43950   {
43951     try {
43952       (arg1)->SetAspectRatio(arg2);
43953     } catch (std::out_of_range& e) {
43954       {
43955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43956       };
43957     } catch (std::exception& e) {
43958       {
43959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43960       };
43961     } catch (...) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43964       };
43965     }
43966   }
43967 }
43968
43969
43970 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetAspectRatio(void * jarg1) {
43971   float jresult ;
43972   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43973   float result;
43974
43975   arg1 = (Dali::CameraActor *)jarg1;
43976   {
43977     try {
43978       result = (float)(arg1)->GetAspectRatio();
43979     } catch (std::out_of_range& e) {
43980       {
43981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43982       };
43983     } catch (std::exception& e) {
43984       {
43985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43990       };
43991     }
43992   }
43993   jresult = result;
43994   return jresult;
43995 }
43996
43997
43998 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
43999   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44000   float arg2 ;
44001
44002   arg1 = (Dali::CameraActor *)jarg1;
44003   arg2 = (float)jarg2;
44004   {
44005     try {
44006       (arg1)->SetNearClippingPlane(arg2);
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44018       };
44019     }
44020   }
44021 }
44022
44023
44024 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetNearClippingPlane(void * jarg1) {
44025   float jresult ;
44026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44027   float result;
44028
44029   arg1 = (Dali::CameraActor *)jarg1;
44030   {
44031     try {
44032       result = (float)(arg1)->GetNearClippingPlane();
44033     } catch (std::out_of_range& e) {
44034       {
44035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44036       };
44037     } catch (std::exception& e) {
44038       {
44039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44040       };
44041     } catch (...) {
44042       {
44043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44044       };
44045     }
44046   }
44047   jresult = result;
44048   return jresult;
44049 }
44050
44051
44052 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44054   float arg2 ;
44055
44056   arg1 = (Dali::CameraActor *)jarg1;
44057   arg2 = (float)jarg2;
44058   {
44059     try {
44060       (arg1)->SetFarClippingPlane(arg2);
44061     } catch (std::out_of_range& e) {
44062       {
44063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44064       };
44065     } catch (std::exception& e) {
44066       {
44067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44068       };
44069     } catch (...) {
44070       {
44071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44072       };
44073     }
44074   }
44075 }
44076
44077
44078 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_CameraActor_GetFarClippingPlane(void * jarg1) {
44079   float jresult ;
44080   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44081   float result;
44082
44083   arg1 = (Dali::CameraActor *)jarg1;
44084   {
44085     try {
44086       result = (float)(arg1)->GetFarClippingPlane();
44087     } catch (std::out_of_range& e) {
44088       {
44089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44090       };
44091     } catch (std::exception& e) {
44092       {
44093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44094       };
44095     } catch (...) {
44096       {
44097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44098       };
44099     }
44100   }
44101   jresult = result;
44102   return jresult;
44103 }
44104
44105
44106 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44107   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44108   Dali::Vector3 *arg2 = 0 ;
44109
44110   arg1 = (Dali::CameraActor *)jarg1;
44111   arg2 = (Dali::Vector3 *)jarg2;
44112   if (!arg2) {
44113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44114     return ;
44115   }
44116   {
44117     try {
44118       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44119     } catch (std::out_of_range& e) {
44120       {
44121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44122       };
44123     } catch (std::exception& e) {
44124       {
44125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44126       };
44127     } catch (...) {
44128       {
44129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44130       };
44131     }
44132   }
44133 }
44134
44135
44136 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CameraActor_GetTargetPosition(void * jarg1) {
44137   void * jresult ;
44138   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44139   Dali::Vector3 result;
44140
44141   arg1 = (Dali::CameraActor *)jarg1;
44142   {
44143     try {
44144       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44145     } catch (std::out_of_range& e) {
44146       {
44147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44148       };
44149     } catch (std::exception& e) {
44150       {
44151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44152       };
44153     } catch (...) {
44154       {
44155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44156       };
44157     }
44158   }
44159   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44160   return jresult;
44161 }
44162
44163
44164 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44165   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44166   bool arg2 ;
44167
44168   arg1 = (Dali::CameraActor *)jarg1;
44169   arg2 = jarg2 ? true : false;
44170   {
44171     try {
44172       (arg1)->SetInvertYAxis(arg2);
44173     } catch (std::out_of_range& e) {
44174       {
44175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44176       };
44177     } catch (std::exception& e) {
44178       {
44179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44180       };
44181     } catch (...) {
44182       {
44183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44184       };
44185     }
44186   }
44187 }
44188
44189
44190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_CameraActor_GetInvertYAxis(void * jarg1) {
44191   unsigned int jresult ;
44192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44193   bool result;
44194
44195   arg1 = (Dali::CameraActor *)jarg1;
44196   {
44197     try {
44198       result = (bool)(arg1)->GetInvertYAxis();
44199     } catch (std::out_of_range& e) {
44200       {
44201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44202       };
44203     } catch (std::exception& e) {
44204       {
44205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44210       };
44211     }
44212   }
44213   jresult = result;
44214   return jresult;
44215 }
44216
44217
44218 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44219   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44220   Dali::Size *arg2 = 0 ;
44221
44222   arg1 = (Dali::CameraActor *)jarg1;
44223   arg2 = (Dali::Size *)jarg2;
44224   if (!arg2) {
44225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44226     return ;
44227   }
44228   {
44229     try {
44230       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44231     } catch (std::out_of_range& e) {
44232       {
44233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44234       };
44235     } catch (std::exception& e) {
44236       {
44237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44238       };
44239     } catch (...) {
44240       {
44241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44242       };
44243     }
44244   }
44245 }
44246
44247
44248 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44250   Dali::Size *arg2 = 0 ;
44251
44252   arg1 = (Dali::CameraActor *)jarg1;
44253   arg2 = (Dali::Size *)jarg2;
44254   if (!arg2) {
44255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44256     return ;
44257   }
44258   {
44259     try {
44260       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44261     } catch (std::out_of_range& e) {
44262       {
44263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44264       };
44265     } catch (std::exception& e) {
44266       {
44267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44268       };
44269     } catch (...) {
44270       {
44271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44272       };
44273     }
44274   }
44275 }
44276
44277
44278 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44279   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44280   float arg2 ;
44281   float arg3 ;
44282   float arg4 ;
44283   float arg5 ;
44284   float arg6 ;
44285   float arg7 ;
44286
44287   arg1 = (Dali::CameraActor *)jarg1;
44288   arg2 = (float)jarg2;
44289   arg3 = (float)jarg3;
44290   arg4 = (float)jarg4;
44291   arg5 = (float)jarg5;
44292   arg6 = (float)jarg6;
44293   arg7 = (float)jarg7;
44294   {
44295     try {
44296       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44304       };
44305     } catch (...) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44308       };
44309     }
44310   }
44311 }
44312
44313
44314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_0() {
44315   void * jresult ;
44316   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44317
44318   {
44319     try {
44320       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (...) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44332       };
44333     }
44334   }
44335   jresult = (void *)result;
44336   return jresult;
44337 }
44338
44339
44340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44341   void * jresult ;
44342   std::string arg1 ;
44343   Dali::Property::Value arg2 ;
44344   Dali::Property::Value *argp2 ;
44345   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44346
44347   if (!jarg1) {
44348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44349     return 0;
44350   }
44351   (&arg1)->assign(jarg1);
44352   argp2 = (Dali::Property::Value *)jarg2;
44353   if (!argp2) {
44354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44355     return 0;
44356   }
44357   arg2 = *argp2;
44358   {
44359     try {
44360       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44361     } catch (std::out_of_range& e) {
44362       {
44363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44364       };
44365     } catch (std::exception& e) {
44366       {
44367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (...) {
44370       {
44371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44372       };
44373     }
44374   }
44375   jresult = (void *)result;
44376   return jresult;
44377 }
44378
44379
44380 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StringValuePair__SWIG_2(void * jarg1) {
44381   void * jresult ;
44382   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44383   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44384
44385   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44386   if (!arg1) {
44387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44388     return 0;
44389   }
44390   {
44391     try {
44392       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);
44393     } catch (std::out_of_range& e) {
44394       {
44395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44396       };
44397     } catch (std::exception& e) {
44398       {
44399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44400       };
44401     } catch (...) {
44402       {
44403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44404       };
44405     }
44406   }
44407   jresult = (void *)result;
44408   return jresult;
44409 }
44410
44411
44412 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StringValuePair_first_set(void * jarg1, char * jarg2) {
44413   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44414   std::string *arg2 = 0 ;
44415
44416   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44417   if (!jarg2) {
44418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44419     return ;
44420   }
44421   std::string arg2_str(jarg2);
44422   arg2 = &arg2_str;
44423   if (arg1) (arg1)->first = *arg2;
44424
44425   //argout typemap for const std::string&
44426
44427 }
44428
44429
44430 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_StringValuePair_first_get(void * jarg1) {
44431   char * jresult ;
44432   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44433   std::string *result = 0 ;
44434
44435   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44436   result = (std::string *) & ((arg1)->first);
44437   jresult = SWIG_csharp_string_callback(result->c_str());
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StringValuePair_second_set(void * jarg1, void * jarg2) {
44443   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44444   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44445
44446   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44447   arg2 = (Dali::Property::Value *)jarg2;
44448   if (arg1) (arg1)->second = *arg2;
44449 }
44450
44451
44452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StringValuePair_second_get(void * jarg1) {
44453   void * jresult ;
44454   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44455   Dali::Property::Value *result = 0 ;
44456
44457   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44458   result = (Dali::Property::Value *)& ((arg1)->second);
44459   jresult = (void *)result;
44460   return jresult;
44461 }
44462
44463
44464 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StringValuePair(void * jarg1) {
44465   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44466
44467   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44468   {
44469     try {
44470       delete arg1;
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (...) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44482       };
44483     }
44484   }
44485 }
44486
44487
44488 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Clear(void * jarg1) {
44489   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44490
44491   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44492   {
44493     try {
44494       (arg1)->clear();
44495     } catch (std::out_of_range& e) {
44496       {
44497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44498       };
44499     } catch (std::exception& e) {
44500       {
44501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44502       };
44503     } catch (...) {
44504       {
44505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44506       };
44507     }
44508   }
44509 }
44510
44511
44512 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44513   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44514   Dali::TouchPoint *arg2 = 0 ;
44515
44516   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44517   arg2 = (Dali::TouchPoint *)jarg2;
44518   if (!arg2) {
44519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44520     return ;
44521   }
44522   {
44523     try {
44524       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44525     } catch (std::out_of_range& e) {
44526       {
44527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44528       };
44529     } catch (std::exception& e) {
44530       {
44531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44536       };
44537     }
44538   }
44539 }
44540
44541
44542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchPointContainer_size(void * jarg1) {
44543   unsigned long jresult ;
44544   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44545   std::vector< Dali::TouchPoint >::size_type result;
44546
44547   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44548   {
44549     try {
44550       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44551     } catch (std::out_of_range& e) {
44552       {
44553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44554       };
44555     } catch (std::exception& e) {
44556       {
44557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44558       };
44559     } catch (...) {
44560       {
44561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44562       };
44563     }
44564   }
44565   jresult = (unsigned long)result;
44566   return jresult;
44567 }
44568
44569
44570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchPointContainer_capacity(void * jarg1) {
44571   unsigned long jresult ;
44572   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44573   std::vector< Dali::TouchPoint >::size_type result;
44574
44575   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44576   {
44577     try {
44578       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44579     } catch (std::out_of_range& e) {
44580       {
44581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44582       };
44583     } catch (std::exception& e) {
44584       {
44585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (...) {
44588       {
44589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44590       };
44591     }
44592   }
44593   jresult = (unsigned long)result;
44594   return jresult;
44595 }
44596
44597
44598 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44599   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44600   std::vector< Dali::TouchPoint >::size_type arg2 ;
44601
44602   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44603   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44604   {
44605     try {
44606       (arg1)->reserve(arg2);
44607     } catch (std::out_of_range& e) {
44608       {
44609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44610       };
44611     } catch (std::exception& e) {
44612       {
44613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44614       };
44615     } catch (...) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44618       };
44619     }
44620   }
44621 }
44622
44623
44624 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_0() {
44625   void * jresult ;
44626   std::vector< Dali::TouchPoint > *result = 0 ;
44627
44628   {
44629     try {
44630       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44631     } catch (std::out_of_range& e) {
44632       {
44633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44634       };
44635     } catch (std::exception& e) {
44636       {
44637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44638       };
44639     } catch (...) {
44640       {
44641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44642       };
44643     }
44644   }
44645   jresult = (void *)result;
44646   return jresult;
44647 }
44648
44649
44650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_1(void * jarg1) {
44651   void * jresult ;
44652   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44653   std::vector< Dali::TouchPoint > *result = 0 ;
44654
44655   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44656   if (!arg1) {
44657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44658     return 0;
44659   }
44660   {
44661     try {
44662       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44663     } catch (std::out_of_range& e) {
44664       {
44665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44666       };
44667     } catch (std::exception& e) {
44668       {
44669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44670       };
44671     } catch (...) {
44672       {
44673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44674       };
44675     }
44676   }
44677   jresult = (void *)result;
44678   return jresult;
44679 }
44680
44681
44682 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchPointContainer__SWIG_2(int jarg1) {
44683   void * jresult ;
44684   int arg1 ;
44685   std::vector< Dali::TouchPoint > *result = 0 ;
44686
44687   arg1 = (int)jarg1;
44688   {
44689     try {
44690       try {
44691         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44692       }
44693       catch(std::out_of_range &_e) {
44694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44695         return 0;
44696       }
44697
44698     } catch (std::out_of_range& e) {
44699       {
44700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44701       };
44702     } catch (std::exception& e) {
44703       {
44704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44705       };
44706     } catch (...) {
44707       {
44708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44709       };
44710     }
44711   }
44712   jresult = (void *)result;
44713   return jresult;
44714 }
44715
44716
44717 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44718   void * jresult ;
44719   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44720   int arg2 ;
44721   SwigValueWrapper< Dali::TouchPoint > result;
44722
44723   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44724   arg2 = (int)jarg2;
44725   {
44726     try {
44727       try {
44728         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44729       }
44730       catch(std::out_of_range &_e) {
44731         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44732         return 0;
44733       }
44734
44735     } catch (std::out_of_range& e) {
44736       {
44737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44738       };
44739     } catch (std::exception& e) {
44740       {
44741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44742       };
44743     } catch (...) {
44744       {
44745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44746       };
44747     }
44748   }
44749   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44750   return jresult;
44751 }
44752
44753
44754 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44755   void * jresult ;
44756   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44757   int arg2 ;
44758   Dali::TouchPoint *result = 0 ;
44759
44760   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44761   arg2 = (int)jarg2;
44762   {
44763     try {
44764       try {
44765         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44766       }
44767       catch(std::out_of_range &_e) {
44768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44769         return 0;
44770       }
44771
44772     } catch (std::out_of_range& e) {
44773       {
44774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44775       };
44776     } catch (std::exception& e) {
44777       {
44778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44779       };
44780     } catch (...) {
44781       {
44782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44783       };
44784     }
44785   }
44786   jresult = (void *)result;
44787   return jresult;
44788 }
44789
44790
44791 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44792   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44793   int arg2 ;
44794   Dali::TouchPoint *arg3 = 0 ;
44795
44796   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44797   arg2 = (int)jarg2;
44798   arg3 = (Dali::TouchPoint *)jarg3;
44799   if (!arg3) {
44800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44801     return ;
44802   }
44803   {
44804     try {
44805       try {
44806         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44807       }
44808       catch(std::out_of_range &_e) {
44809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44810         return ;
44811       }
44812
44813     } catch (std::out_of_range& e) {
44814       {
44815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44816       };
44817     } catch (std::exception& e) {
44818       {
44819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44820       };
44821     } catch (...) {
44822       {
44823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44824       };
44825     }
44826   }
44827 }
44828
44829
44830 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44831   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44832   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44833
44834   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44835   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44836   if (!arg2) {
44837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44838     return ;
44839   }
44840   {
44841     try {
44842       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
44843     } catch (std::out_of_range& e) {
44844       {
44845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44846       };
44847     } catch (std::exception& e) {
44848       {
44849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44850       };
44851     } catch (...) {
44852       {
44853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44854       };
44855     }
44856   }
44857 }
44858
44859
44860 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
44861   void * jresult ;
44862   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44863   int arg2 ;
44864   int arg3 ;
44865   std::vector< Dali::TouchPoint > *result = 0 ;
44866
44867   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44868   arg2 = (int)jarg2;
44869   arg3 = (int)jarg3;
44870   {
44871     try {
44872       try {
44873         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
44874       }
44875       catch(std::out_of_range &_e) {
44876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44877         return 0;
44878       }
44879       catch(std::invalid_argument &_e) {
44880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44881         return 0;
44882       }
44883
44884     } catch (std::out_of_range& e) {
44885       {
44886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44887       };
44888     } catch (std::exception& e) {
44889       {
44890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44891       };
44892     } catch (...) {
44893       {
44894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44895       };
44896     }
44897   }
44898   jresult = (void *)result;
44899   return jresult;
44900 }
44901
44902
44903 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
44904   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44905   int arg2 ;
44906   Dali::TouchPoint *arg3 = 0 ;
44907
44908   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44909   arg2 = (int)jarg2;
44910   arg3 = (Dali::TouchPoint *)jarg3;
44911   if (!arg3) {
44912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44913     return ;
44914   }
44915   {
44916     try {
44917       try {
44918         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44919       }
44920       catch(std::out_of_range &_e) {
44921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44922         return ;
44923       }
44924
44925     } catch (std::out_of_range& e) {
44926       {
44927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44928       };
44929     } catch (std::exception& e) {
44930       {
44931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44932       };
44933     } catch (...) {
44934       {
44935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44936       };
44937     }
44938   }
44939 }
44940
44941
44942 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
44943   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44944   int arg2 ;
44945   std::vector< Dali::TouchPoint > *arg3 = 0 ;
44946
44947   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44948   arg2 = (int)jarg2;
44949   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
44950   if (!arg3) {
44951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44952     return ;
44953   }
44954   {
44955     try {
44956       try {
44957         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
44958       }
44959       catch(std::out_of_range &_e) {
44960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44961         return ;
44962       }
44963
44964     } catch (std::out_of_range& e) {
44965       {
44966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44967       };
44968     } catch (std::exception& e) {
44969       {
44970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44971       };
44972     } catch (...) {
44973       {
44974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44975       };
44976     }
44977   }
44978 }
44979
44980
44981 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
44982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44983   int arg2 ;
44984
44985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44986   arg2 = (int)jarg2;
44987   {
44988     try {
44989       try {
44990         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
44991       }
44992       catch(std::out_of_range &_e) {
44993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44994         return ;
44995       }
44996
44997     } catch (std::out_of_range& e) {
44998       {
44999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45000       };
45001     } catch (std::exception& e) {
45002       {
45003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45004       };
45005     } catch (...) {
45006       {
45007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45008       };
45009     }
45010   }
45011 }
45012
45013
45014 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45015   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45016   int arg2 ;
45017   int arg3 ;
45018
45019   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45020   arg2 = (int)jarg2;
45021   arg3 = (int)jarg3;
45022   {
45023     try {
45024       try {
45025         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45026       }
45027       catch(std::out_of_range &_e) {
45028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45029         return ;
45030       }
45031       catch(std::invalid_argument &_e) {
45032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45033         return ;
45034       }
45035
45036     } catch (std::out_of_range& e) {
45037       {
45038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45039       };
45040     } catch (std::exception& e) {
45041       {
45042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45043       };
45044     } catch (...) {
45045       {
45046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45047       };
45048     }
45049   }
45050 }
45051
45052
45053 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45054   void * jresult ;
45055   Dali::TouchPoint *arg1 = 0 ;
45056   int arg2 ;
45057   std::vector< Dali::TouchPoint > *result = 0 ;
45058
45059   arg1 = (Dali::TouchPoint *)jarg1;
45060   if (!arg1) {
45061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45062     return 0;
45063   }
45064   arg2 = (int)jarg2;
45065   {
45066     try {
45067       try {
45068         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45069       }
45070       catch(std::out_of_range &_e) {
45071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45072         return 0;
45073       }
45074
45075     } catch (std::out_of_range& e) {
45076       {
45077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45078       };
45079     } catch (std::exception& e) {
45080       {
45081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45082       };
45083     } catch (...) {
45084       {
45085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45086       };
45087     }
45088   }
45089   jresult = (void *)result;
45090   return jresult;
45091 }
45092
45093
45094 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45095   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45096
45097   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45098   {
45099     try {
45100       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45101     } catch (std::out_of_range& e) {
45102       {
45103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45104       };
45105     } catch (std::exception& e) {
45106       {
45107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45112       };
45113     }
45114   }
45115 }
45116
45117
45118 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45119   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45120   int arg2 ;
45121   int arg3 ;
45122
45123   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45124   arg2 = (int)jarg2;
45125   arg3 = (int)jarg3;
45126   {
45127     try {
45128       try {
45129         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45130       }
45131       catch(std::out_of_range &_e) {
45132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45133         return ;
45134       }
45135       catch(std::invalid_argument &_e) {
45136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45137         return ;
45138       }
45139
45140     } catch (std::out_of_range& e) {
45141       {
45142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45143       };
45144     } catch (std::exception& e) {
45145       {
45146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45147       };
45148     } catch (...) {
45149       {
45150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45151       };
45152     }
45153   }
45154 }
45155
45156
45157 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45158   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45159   int arg2 ;
45160   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45161
45162   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45163   arg2 = (int)jarg2;
45164   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45165   if (!arg3) {
45166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45167     return ;
45168   }
45169   {
45170     try {
45171       try {
45172         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45173       }
45174       catch(std::out_of_range &_e) {
45175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45176         return ;
45177       }
45178
45179     } catch (std::out_of_range& e) {
45180       {
45181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45182       };
45183     } catch (std::exception& e) {
45184       {
45185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45186       };
45187     } catch (...) {
45188       {
45189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45190       };
45191     }
45192   }
45193 }
45194
45195
45196 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchPointContainer(void * jarg1) {
45197   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45198
45199   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45200   {
45201     try {
45202       delete arg1;
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45210       };
45211     } catch (...) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45214       };
45215     }
45216   }
45217 }
45218
45219
45220 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_0() {
45221   void * jresult ;
45222   Dali::Rect< double > *result = 0 ;
45223
45224   {
45225     try {
45226       result = (Dali::Rect< double > *)new Dali::Rect< double >();
45227     } catch (std::out_of_range& e) {
45228       {
45229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45230       };
45231     } catch (std::exception& e) {
45232       {
45233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (...) {
45236       {
45237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45238       };
45239     }
45240   }
45241   jresult = (void *)result;
45242   return jresult;
45243 }
45244
45245
45246 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4) {
45247   void * jresult ;
45248   double arg1 ;
45249   double arg2 ;
45250   double arg3 ;
45251   double arg4 ;
45252   Dali::Rect< double > *result = 0 ;
45253
45254   arg1 = (double)jarg1;
45255   arg2 = (double)jarg2;
45256   arg3 = (double)jarg3;
45257   arg4 = (double)jarg4;
45258   {
45259     try {
45260       result = (Dali::Rect< double > *)new Dali::Rect< double >(arg1,arg2,arg3,arg4);
45261     } catch (std::out_of_range& e) {
45262       {
45263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45264       };
45265     } catch (std::exception& e) {
45266       {
45267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45268       };
45269     } catch (...) {
45270       {
45271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45272       };
45273     }
45274   }
45275   jresult = (void *)result;
45276   return jresult;
45277 }
45278
45279
45280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectDouble__SWIG_2(void * jarg1) {
45281   void * jresult ;
45282   Dali::Rect< double > *arg1 = 0 ;
45283   Dali::Rect< double > *result = 0 ;
45284
45285   arg1 = (Dali::Rect< double > *)jarg1;
45286   if (!arg1) {
45287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45288     return 0;
45289   }
45290   {
45291     try {
45292       result = (Dali::Rect< double > *)new Dali::Rect< double >((Dali::Rect< double > const &)*arg1);
45293     } catch (std::out_of_range& e) {
45294       {
45295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45296       };
45297     } catch (std::exception& e) {
45298       {
45299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45300       };
45301     } catch (...) {
45302       {
45303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45304       };
45305     }
45306   }
45307   jresult = (void *)result;
45308   return jresult;
45309 }
45310
45311
45312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectDouble_Assign(void * jarg1, void * jarg2) {
45313   void * jresult ;
45314   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45315   Dali::Rect< double > *arg2 = 0 ;
45316   Dali::Rect< double > *result = 0 ;
45317
45318   arg1 = (Dali::Rect< double > *)jarg1;
45319   arg2 = (Dali::Rect< double > *)jarg2;
45320   if (!arg2) {
45321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45322     return 0;
45323   }
45324   {
45325     try {
45326       result = (Dali::Rect< double > *) &(arg1)->operator =((Dali::Rect< double > const &)*arg2);
45327     } catch (std::out_of_range& e) {
45328       {
45329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45330       };
45331     } catch (std::exception& e) {
45332       {
45333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45334       };
45335     } catch (...) {
45336       {
45337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45338       };
45339     }
45340   }
45341   jresult = (void *)result;
45342   return jresult;
45343 }
45344
45345
45346 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_Set(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
45347   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45348   double arg2 ;
45349   double arg3 ;
45350   double arg4 ;
45351   double arg5 ;
45352
45353   arg1 = (Dali::Rect< double > *)jarg1;
45354   arg2 = (double)jarg2;
45355   arg3 = (double)jarg3;
45356   arg4 = (double)jarg4;
45357   arg5 = (double)jarg5;
45358   {
45359     try {
45360       (arg1)->Set(arg2,arg3,arg4,arg5);
45361     } catch (std::out_of_range& e) {
45362       {
45363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45364       };
45365     } catch (std::exception& e) {
45366       {
45367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45368       };
45369     } catch (...) {
45370       {
45371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45372       };
45373     }
45374   }
45375 }
45376
45377
45378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_IsEmpty(void * jarg1) {
45379   unsigned int jresult ;
45380   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45381   bool result;
45382
45383   arg1 = (Dali::Rect< double > *)jarg1;
45384   {
45385     try {
45386       result = (bool)((Dali::Rect< double > const *)arg1)->IsEmpty();
45387     } catch (std::out_of_range& e) {
45388       {
45389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45390       };
45391     } catch (std::exception& e) {
45392       {
45393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45394       };
45395     } catch (...) {
45396       {
45397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45398       };
45399     }
45400   }
45401   jresult = result;
45402   return jresult;
45403 }
45404
45405
45406 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Left(void * jarg1) {
45407   double jresult ;
45408   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45409   double result;
45410
45411   arg1 = (Dali::Rect< double > *)jarg1;
45412   {
45413     try {
45414       result = (double)((Dali::Rect< double > const *)arg1)->Left();
45415     } catch (std::out_of_range& e) {
45416       {
45417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45418       };
45419     } catch (std::exception& e) {
45420       {
45421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45422       };
45423     } catch (...) {
45424       {
45425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45426       };
45427     }
45428   }
45429   jresult = result;
45430   return jresult;
45431 }
45432
45433
45434 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Right(void * jarg1) {
45435   double jresult ;
45436   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45437   double result;
45438
45439   arg1 = (Dali::Rect< double > *)jarg1;
45440   {
45441     try {
45442       result = (double)((Dali::Rect< double > const *)arg1)->Right();
45443     } catch (std::out_of_range& e) {
45444       {
45445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45446       };
45447     } catch (std::exception& e) {
45448       {
45449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45450       };
45451     } catch (...) {
45452       {
45453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45454       };
45455     }
45456   }
45457   jresult = result;
45458   return jresult;
45459 }
45460
45461
45462 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Top(void * jarg1) {
45463   double jresult ;
45464   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45465   double result;
45466
45467   arg1 = (Dali::Rect< double > *)jarg1;
45468   {
45469     try {
45470       result = (double)((Dali::Rect< double > const *)arg1)->Top();
45471     } catch (std::out_of_range& e) {
45472       {
45473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (std::exception& e) {
45476       {
45477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45478       };
45479     } catch (...) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45482       };
45483     }
45484   }
45485   jresult = result;
45486   return jresult;
45487 }
45488
45489
45490 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Bottom(void * jarg1) {
45491   double jresult ;
45492   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45493   double result;
45494
45495   arg1 = (Dali::Rect< double > *)jarg1;
45496   {
45497     try {
45498       result = (double)((Dali::Rect< double > const *)arg1)->Bottom();
45499     } catch (std::out_of_range& e) {
45500       {
45501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45502       };
45503     } catch (std::exception& e) {
45504       {
45505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45506       };
45507     } catch (...) {
45508       {
45509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45510       };
45511     }
45512   }
45513   jresult = result;
45514   return jresult;
45515 }
45516
45517
45518 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_Area(void * jarg1) {
45519   double jresult ;
45520   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45521   double result;
45522
45523   arg1 = (Dali::Rect< double > *)jarg1;
45524   {
45525     try {
45526       result = (double)((Dali::Rect< double > const *)arg1)->Area();
45527     } catch (std::out_of_range& e) {
45528       {
45529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45530       };
45531     } catch (std::exception& e) {
45532       {
45533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45534       };
45535     } catch (...) {
45536       {
45537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45538       };
45539     }
45540   }
45541   jresult = result;
45542   return jresult;
45543 }
45544
45545
45546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_Intersects(void * jarg1, void * jarg2) {
45547   unsigned int jresult ;
45548   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45549   Dali::Rect< double > *arg2 = 0 ;
45550   bool result;
45551
45552   arg1 = (Dali::Rect< double > *)jarg1;
45553   arg2 = (Dali::Rect< double > *)jarg2;
45554   if (!arg2) {
45555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45556     return 0;
45557   }
45558   {
45559     try {
45560       result = (bool)((Dali::Rect< double > const *)arg1)->Intersects((Dali::Rect< double > const &)*arg2);
45561     } catch (std::out_of_range& e) {
45562       {
45563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45564       };
45565     } catch (std::exception& e) {
45566       {
45567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45568       };
45569     } catch (...) {
45570       {
45571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45572       };
45573     }
45574   }
45575   jresult = result;
45576   return jresult;
45577 }
45578
45579
45580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectDouble_Contains(void * jarg1, void * jarg2) {
45581   unsigned int jresult ;
45582   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45583   Dali::Rect< double > *arg2 = 0 ;
45584   bool result;
45585
45586   arg1 = (Dali::Rect< double > *)jarg1;
45587   arg2 = (Dali::Rect< double > *)jarg2;
45588   if (!arg2) {
45589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45590     return 0;
45591   }
45592   {
45593     try {
45594       result = (bool)((Dali::Rect< double > const *)arg1)->Contains((Dali::Rect< double > const &)*arg2);
45595     } catch (std::out_of_range& e) {
45596       {
45597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (std::exception& e) {
45600       {
45601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (...) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45606       };
45607     }
45608   }
45609   jresult = result;
45610   return jresult;
45611 }
45612
45613
45614 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_x_set(void * jarg1, double jarg2) {
45615   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45616   double arg2 ;
45617
45618   arg1 = (Dali::Rect< double > *)jarg1;
45619   arg2 = (double)jarg2;
45620   if (arg1) (arg1)->x = arg2;
45621 }
45622
45623
45624 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_x_get(void * jarg1) {
45625   double jresult ;
45626   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45627   double result;
45628
45629   arg1 = (Dali::Rect< double > *)jarg1;
45630   result = (double) ((arg1)->x);
45631   jresult = result;
45632   return jresult;
45633 }
45634
45635
45636 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_left_set(void * jarg1, double jarg2) {
45637   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45638   double arg2 ;
45639
45640   arg1 = (Dali::Rect< double > *)jarg1;
45641   arg2 = (double)jarg2;
45642   if (arg1) (arg1)->left = arg2;
45643 }
45644
45645
45646 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_left_get(void * jarg1) {
45647   double jresult ;
45648   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45649   double result;
45650
45651   arg1 = (Dali::Rect< double > *)jarg1;
45652   result = (double) ((arg1)->left);
45653   jresult = result;
45654   return jresult;
45655 }
45656
45657
45658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_y_set(void * jarg1, double jarg2) {
45659   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45660   double arg2 ;
45661
45662   arg1 = (Dali::Rect< double > *)jarg1;
45663   arg2 = (double)jarg2;
45664   if (arg1) (arg1)->y = arg2;
45665 }
45666
45667
45668 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_y_get(void * jarg1) {
45669   double jresult ;
45670   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45671   double result;
45672
45673   arg1 = (Dali::Rect< double > *)jarg1;
45674   result = (double) ((arg1)->y);
45675   jresult = result;
45676   return jresult;
45677 }
45678
45679
45680 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_right_set(void * jarg1, double jarg2) {
45681   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45682   double arg2 ;
45683
45684   arg1 = (Dali::Rect< double > *)jarg1;
45685   arg2 = (double)jarg2;
45686   if (arg1) (arg1)->right = arg2;
45687 }
45688
45689
45690 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_right_get(void * jarg1) {
45691   double jresult ;
45692   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45693   double result;
45694
45695   arg1 = (Dali::Rect< double > *)jarg1;
45696   result = (double) ((arg1)->right);
45697   jresult = result;
45698   return jresult;
45699 }
45700
45701
45702 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_width_set(void * jarg1, double jarg2) {
45703   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45704   double arg2 ;
45705
45706   arg1 = (Dali::Rect< double > *)jarg1;
45707   arg2 = (double)jarg2;
45708   if (arg1) (arg1)->width = arg2;
45709 }
45710
45711
45712 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_width_get(void * jarg1) {
45713   double jresult ;
45714   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45715   double result;
45716
45717   arg1 = (Dali::Rect< double > *)jarg1;
45718   result = (double) ((arg1)->width);
45719   jresult = result;
45720   return jresult;
45721 }
45722
45723
45724 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_bottom_set(void * jarg1, double jarg2) {
45725   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45726   double arg2 ;
45727
45728   arg1 = (Dali::Rect< double > *)jarg1;
45729   arg2 = (double)jarg2;
45730   if (arg1) (arg1)->bottom = arg2;
45731 }
45732
45733
45734 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_bottom_get(void * jarg1) {
45735   double jresult ;
45736   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45737   double result;
45738
45739   arg1 = (Dali::Rect< double > *)jarg1;
45740   result = (double) ((arg1)->bottom);
45741   jresult = result;
45742   return jresult;
45743 }
45744
45745
45746 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_height_set(void * jarg1, double jarg2) {
45747   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45748   double arg2 ;
45749
45750   arg1 = (Dali::Rect< double > *)jarg1;
45751   arg2 = (double)jarg2;
45752   if (arg1) (arg1)->height = arg2;
45753 }
45754
45755
45756 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_height_get(void * jarg1) {
45757   double jresult ;
45758   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45759   double result;
45760
45761   arg1 = (Dali::Rect< double > *)jarg1;
45762   result = (double) ((arg1)->height);
45763   jresult = result;
45764   return jresult;
45765 }
45766
45767
45768 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectDouble_top_set(void * jarg1, double jarg2) {
45769   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45770   double arg2 ;
45771
45772   arg1 = (Dali::Rect< double > *)jarg1;
45773   arg2 = (double)jarg2;
45774   if (arg1) (arg1)->top = arg2;
45775 }
45776
45777
45778 SWIGEXPORT double SWIGSTDCALL CSharp_NUI_RectDouble_top_get(void * jarg1) {
45779   double jresult ;
45780   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45781   double result;
45782
45783   arg1 = (Dali::Rect< double > *)jarg1;
45784   result = (double) ((arg1)->top);
45785   jresult = result;
45786   return jresult;
45787 }
45788
45789
45790 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectDouble(void * jarg1) {
45791   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45792
45793   arg1 = (Dali::Rect< double > *)jarg1;
45794   {
45795     try {
45796       delete arg1;
45797     } catch (std::out_of_range& e) {
45798       {
45799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45800       };
45801     } catch (std::exception& e) {
45802       {
45803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45804       };
45805     } catch (...) {
45806       {
45807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45808       };
45809     }
45810   }
45811 }
45812
45813
45814 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_0() {
45815   void * jresult ;
45816   Dali::Rect< int > *result = 0 ;
45817
45818   {
45819     try {
45820       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45821     } catch (std::out_of_range& e) {
45822       {
45823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45824       };
45825     } catch (std::exception& e) {
45826       {
45827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (...) {
45830       {
45831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45832       };
45833     }
45834   }
45835   jresult = (void *)result;
45836   return jresult;
45837 }
45838
45839
45840 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45841   void * jresult ;
45842   int arg1 ;
45843   int arg2 ;
45844   int arg3 ;
45845   int arg4 ;
45846   Dali::Rect< int > *result = 0 ;
45847
45848   arg1 = (int)jarg1;
45849   arg2 = (int)jarg2;
45850   arg3 = (int)jarg3;
45851   arg4 = (int)jarg4;
45852   {
45853     try {
45854       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45855     } catch (std::out_of_range& e) {
45856       {
45857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45858       };
45859     } catch (std::exception& e) {
45860       {
45861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45862       };
45863     } catch (...) {
45864       {
45865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45866       };
45867     }
45868   }
45869   jresult = (void *)result;
45870   return jresult;
45871 }
45872
45873
45874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectInteger__SWIG_2(void * jarg1) {
45875   void * jresult ;
45876   Dali::Rect< int > *arg1 = 0 ;
45877   Dali::Rect< int > *result = 0 ;
45878
45879   arg1 = (Dali::Rect< int > *)jarg1;
45880   if (!arg1) {
45881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45882     return 0;
45883   }
45884   {
45885     try {
45886       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45887     } catch (std::out_of_range& e) {
45888       {
45889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45890       };
45891     } catch (std::exception& e) {
45892       {
45893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45894       };
45895     } catch (...) {
45896       {
45897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45898       };
45899     }
45900   }
45901   jresult = (void *)result;
45902   return jresult;
45903 }
45904
45905
45906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectInteger_Assign(void * jarg1, void * jarg2) {
45907   void * jresult ;
45908   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45909   Dali::Rect< int > *arg2 = 0 ;
45910   Dali::Rect< int > *result = 0 ;
45911
45912   arg1 = (Dali::Rect< int > *)jarg1;
45913   arg2 = (Dali::Rect< int > *)jarg2;
45914   if (!arg2) {
45915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45916     return 0;
45917   }
45918   {
45919     try {
45920       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45921     } catch (std::out_of_range& e) {
45922       {
45923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45924       };
45925     } catch (std::exception& e) {
45926       {
45927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45928       };
45929     } catch (...) {
45930       {
45931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45932       };
45933     }
45934   }
45935   jresult = (void *)result;
45936   return jresult;
45937 }
45938
45939
45940 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45941   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45942   int arg2 ;
45943   int arg3 ;
45944   int arg4 ;
45945   int arg5 ;
45946
45947   arg1 = (Dali::Rect< int > *)jarg1;
45948   arg2 = (int)jarg2;
45949   arg3 = (int)jarg3;
45950   arg4 = (int)jarg4;
45951   arg5 = (int)jarg5;
45952   {
45953     try {
45954       (arg1)->Set(arg2,arg3,arg4,arg5);
45955     } catch (std::out_of_range& e) {
45956       {
45957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45958       };
45959     } catch (std::exception& e) {
45960       {
45961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45962       };
45963     } catch (...) {
45964       {
45965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45966       };
45967     }
45968   }
45969 }
45970
45971
45972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_IsEmpty(void * jarg1) {
45973   unsigned int jresult ;
45974   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45975   bool result;
45976
45977   arg1 = (Dali::Rect< int > *)jarg1;
45978   {
45979     try {
45980       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45981     } catch (std::out_of_range& e) {
45982       {
45983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45984       };
45985     } catch (std::exception& e) {
45986       {
45987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45988       };
45989     } catch (...) {
45990       {
45991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45992       };
45993     }
45994   }
45995   jresult = result;
45996   return jresult;
45997 }
45998
45999
46000 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Left(void * jarg1) {
46001   int jresult ;
46002   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46003   int result;
46004
46005   arg1 = (Dali::Rect< int > *)jarg1;
46006   {
46007     try {
46008       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46009     } catch (std::out_of_range& e) {
46010       {
46011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46012       };
46013     } catch (std::exception& e) {
46014       {
46015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46016       };
46017     } catch (...) {
46018       {
46019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46020       };
46021     }
46022   }
46023   jresult = result;
46024   return jresult;
46025 }
46026
46027
46028 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Right(void * jarg1) {
46029   int jresult ;
46030   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46031   int result;
46032
46033   arg1 = (Dali::Rect< int > *)jarg1;
46034   {
46035     try {
46036       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46037     } catch (std::out_of_range& e) {
46038       {
46039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (std::exception& e) {
46042       {
46043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (...) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46048       };
46049     }
46050   }
46051   jresult = result;
46052   return jresult;
46053 }
46054
46055
46056 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Top(void * jarg1) {
46057   int jresult ;
46058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46059   int result;
46060
46061   arg1 = (Dali::Rect< int > *)jarg1;
46062   {
46063     try {
46064       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46065     } catch (std::out_of_range& e) {
46066       {
46067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46068       };
46069     } catch (std::exception& e) {
46070       {
46071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46072       };
46073     } catch (...) {
46074       {
46075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46076       };
46077     }
46078   }
46079   jresult = result;
46080   return jresult;
46081 }
46082
46083
46084 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Bottom(void * jarg1) {
46085   int jresult ;
46086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46087   int result;
46088
46089   arg1 = (Dali::Rect< int > *)jarg1;
46090   {
46091     try {
46092       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46093     } catch (std::out_of_range& e) {
46094       {
46095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46096       };
46097     } catch (std::exception& e) {
46098       {
46099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46100       };
46101     } catch (...) {
46102       {
46103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46104       };
46105     }
46106   }
46107   jresult = result;
46108   return jresult;
46109 }
46110
46111
46112 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_Area(void * jarg1) {
46113   int jresult ;
46114   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46115   int result;
46116
46117   arg1 = (Dali::Rect< int > *)jarg1;
46118   {
46119     try {
46120       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46121     } catch (std::out_of_range& e) {
46122       {
46123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46124       };
46125     } catch (std::exception& e) {
46126       {
46127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46128       };
46129     } catch (...) {
46130       {
46131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46132       };
46133     }
46134   }
46135   jresult = result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_Intersects(void * jarg1, void * jarg2) {
46141   unsigned int jresult ;
46142   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46143   Dali::Rect< int > *arg2 = 0 ;
46144   bool result;
46145
46146   arg1 = (Dali::Rect< int > *)jarg1;
46147   arg2 = (Dali::Rect< int > *)jarg2;
46148   if (!arg2) {
46149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46150     return 0;
46151   }
46152   {
46153     try {
46154       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46155     } catch (std::out_of_range& e) {
46156       {
46157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46158       };
46159     } catch (std::exception& e) {
46160       {
46161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46162       };
46163     } catch (...) {
46164       {
46165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46166       };
46167     }
46168   }
46169   jresult = result;
46170   return jresult;
46171 }
46172
46173
46174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectInteger_Contains(void * jarg1, void * jarg2) {
46175   unsigned int jresult ;
46176   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46177   Dali::Rect< int > *arg2 = 0 ;
46178   bool result;
46179
46180   arg1 = (Dali::Rect< int > *)jarg1;
46181   arg2 = (Dali::Rect< int > *)jarg2;
46182   if (!arg2) {
46183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46184     return 0;
46185   }
46186   {
46187     try {
46188       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46189     } catch (std::out_of_range& e) {
46190       {
46191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46192       };
46193     } catch (std::exception& e) {
46194       {
46195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (...) {
46198       {
46199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46200       };
46201     }
46202   }
46203   jresult = result;
46204   return jresult;
46205 }
46206
46207
46208 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_x_set(void * jarg1, int jarg2) {
46209   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46210   int arg2 ;
46211
46212   arg1 = (Dali::Rect< int > *)jarg1;
46213   arg2 = (int)jarg2;
46214   if (arg1) (arg1)->x = arg2;
46215 }
46216
46217
46218 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_x_get(void * jarg1) {
46219   int jresult ;
46220   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46221   int result;
46222
46223   arg1 = (Dali::Rect< int > *)jarg1;
46224   result = (int) ((arg1)->x);
46225   jresult = result;
46226   return jresult;
46227 }
46228
46229
46230 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_left_set(void * jarg1, int jarg2) {
46231   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46232   int arg2 ;
46233
46234   arg1 = (Dali::Rect< int > *)jarg1;
46235   arg2 = (int)jarg2;
46236   if (arg1) (arg1)->left = arg2;
46237 }
46238
46239
46240 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_left_get(void * jarg1) {
46241   int jresult ;
46242   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46243   int result;
46244
46245   arg1 = (Dali::Rect< int > *)jarg1;
46246   result = (int) ((arg1)->left);
46247   jresult = result;
46248   return jresult;
46249 }
46250
46251
46252 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_y_set(void * jarg1, int jarg2) {
46253   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46254   int arg2 ;
46255
46256   arg1 = (Dali::Rect< int > *)jarg1;
46257   arg2 = (int)jarg2;
46258   if (arg1) (arg1)->y = arg2;
46259 }
46260
46261
46262 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_y_get(void * jarg1) {
46263   int jresult ;
46264   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46265   int result;
46266
46267   arg1 = (Dali::Rect< int > *)jarg1;
46268   result = (int) ((arg1)->y);
46269   jresult = result;
46270   return jresult;
46271 }
46272
46273
46274 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_right_set(void * jarg1, int jarg2) {
46275   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46276   int arg2 ;
46277
46278   arg1 = (Dali::Rect< int > *)jarg1;
46279   arg2 = (int)jarg2;
46280   if (arg1) (arg1)->right = arg2;
46281 }
46282
46283
46284 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_right_get(void * jarg1) {
46285   int jresult ;
46286   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46287   int result;
46288
46289   arg1 = (Dali::Rect< int > *)jarg1;
46290   result = (int) ((arg1)->right);
46291   jresult = result;
46292   return jresult;
46293 }
46294
46295
46296 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_width_set(void * jarg1, int jarg2) {
46297   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46298   int arg2 ;
46299
46300   arg1 = (Dali::Rect< int > *)jarg1;
46301   arg2 = (int)jarg2;
46302   if (arg1) (arg1)->width = arg2;
46303 }
46304
46305
46306 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_width_get(void * jarg1) {
46307   int jresult ;
46308   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46309   int result;
46310
46311   arg1 = (Dali::Rect< int > *)jarg1;
46312   result = (int) ((arg1)->width);
46313   jresult = result;
46314   return jresult;
46315 }
46316
46317
46318 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_bottom_set(void * jarg1, int jarg2) {
46319   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46320   int arg2 ;
46321
46322   arg1 = (Dali::Rect< int > *)jarg1;
46323   arg2 = (int)jarg2;
46324   if (arg1) (arg1)->bottom = arg2;
46325 }
46326
46327
46328 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_bottom_get(void * jarg1) {
46329   int jresult ;
46330   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46331   int result;
46332
46333   arg1 = (Dali::Rect< int > *)jarg1;
46334   result = (int) ((arg1)->bottom);
46335   jresult = result;
46336   return jresult;
46337 }
46338
46339
46340 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_height_set(void * jarg1, int jarg2) {
46341   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46342   int arg2 ;
46343
46344   arg1 = (Dali::Rect< int > *)jarg1;
46345   arg2 = (int)jarg2;
46346   if (arg1) (arg1)->height = arg2;
46347 }
46348
46349
46350 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_height_get(void * jarg1) {
46351   int jresult ;
46352   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46353   int result;
46354
46355   arg1 = (Dali::Rect< int > *)jarg1;
46356   result = (int) ((arg1)->height);
46357   jresult = result;
46358   return jresult;
46359 }
46360
46361
46362 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectInteger_top_set(void * jarg1, int jarg2) {
46363   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46364   int arg2 ;
46365
46366   arg1 = (Dali::Rect< int > *)jarg1;
46367   arg2 = (int)jarg2;
46368   if (arg1) (arg1)->top = arg2;
46369 }
46370
46371
46372 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RectInteger_top_get(void * jarg1) {
46373   int jresult ;
46374   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46375   int result;
46376
46377   arg1 = (Dali::Rect< int > *)jarg1;
46378   result = (int) ((arg1)->top);
46379   jresult = result;
46380   return jresult;
46381 }
46382
46383
46384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectInteger(void * jarg1) {
46385   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46386
46387   arg1 = (Dali::Rect< int > *)jarg1;
46388   {
46389     try {
46390       delete arg1;
46391     } catch (std::out_of_range& e) {
46392       {
46393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46394       };
46395     } catch (std::exception& e) {
46396       {
46397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46398       };
46399     } catch (...) {
46400       {
46401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46402       };
46403     }
46404   }
46405 }
46406
46407
46408 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_0() {
46409   void * jresult ;
46410   Dali::Rect< unsigned int > *result = 0 ;
46411
46412   {
46413     try {
46414       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >();
46415     } catch (std::out_of_range& e) {
46416       {
46417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46418       };
46419     } catch (std::exception& e) {
46420       {
46421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46422       };
46423     } catch (...) {
46424       {
46425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46426       };
46427     }
46428   }
46429   jresult = (void *)result;
46430   return jresult;
46431 }
46432
46433
46434 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46435   void * jresult ;
46436   unsigned int arg1 ;
46437   unsigned int arg2 ;
46438   unsigned int arg3 ;
46439   unsigned int arg4 ;
46440   Dali::Rect< unsigned int > *result = 0 ;
46441
46442   arg1 = (unsigned int)jarg1;
46443   arg2 = (unsigned int)jarg2;
46444   arg3 = (unsigned int)jarg3;
46445   arg4 = (unsigned int)jarg4;
46446   {
46447     try {
46448       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >(arg1,arg2,arg3,arg4);
46449     } catch (std::out_of_range& e) {
46450       {
46451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46452       };
46453     } catch (std::exception& e) {
46454       {
46455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46456       };
46457     } catch (...) {
46458       {
46459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46460       };
46461     }
46462   }
46463   jresult = (void *)result;
46464   return jresult;
46465 }
46466
46467
46468 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectUnsignedInteger__SWIG_2(void * jarg1) {
46469   void * jresult ;
46470   Dali::Rect< unsigned int > *arg1 = 0 ;
46471   Dali::Rect< unsigned int > *result = 0 ;
46472
46473   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46474   if (!arg1) {
46475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46476     return 0;
46477   }
46478   {
46479     try {
46480       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >((Dali::Rect< unsigned int > const &)*arg1);
46481     } catch (std::out_of_range& e) {
46482       {
46483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46484       };
46485     } catch (std::exception& e) {
46486       {
46487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46488       };
46489     } catch (...) {
46490       {
46491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46492       };
46493     }
46494   }
46495   jresult = (void *)result;
46496   return jresult;
46497 }
46498
46499
46500 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Assign(void * jarg1, void * jarg2) {
46501   void * jresult ;
46502   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46503   Dali::Rect< unsigned int > *arg2 = 0 ;
46504   Dali::Rect< unsigned int > *result = 0 ;
46505
46506   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46507   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46508   if (!arg2) {
46509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46510     return 0;
46511   }
46512   {
46513     try {
46514       result = (Dali::Rect< unsigned int > *) &(arg1)->operator =((Dali::Rect< unsigned int > const &)*arg2);
46515     } catch (std::out_of_range& e) {
46516       {
46517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (std::exception& e) {
46520       {
46521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46526       };
46527     }
46528   }
46529   jresult = (void *)result;
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Set(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
46535   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46536   unsigned int arg2 ;
46537   unsigned int arg3 ;
46538   unsigned int arg4 ;
46539   unsigned int arg5 ;
46540
46541   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46542   arg2 = (unsigned int)jarg2;
46543   arg3 = (unsigned int)jarg3;
46544   arg4 = (unsigned int)jarg4;
46545   arg5 = (unsigned int)jarg5;
46546   {
46547     try {
46548       (arg1)->Set(arg2,arg3,arg4,arg5);
46549     } catch (std::out_of_range& e) {
46550       {
46551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46552       };
46553     } catch (std::exception& e) {
46554       {
46555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46556       };
46557     } catch (...) {
46558       {
46559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46560       };
46561     }
46562   }
46563 }
46564
46565
46566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_IsEmpty(void * jarg1) {
46567   unsigned int jresult ;
46568   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46569   bool result;
46570
46571   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46572   {
46573     try {
46574       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->IsEmpty();
46575     } catch (std::out_of_range& e) {
46576       {
46577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46578       };
46579     } catch (std::exception& e) {
46580       {
46581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46582       };
46583     } catch (...) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46586       };
46587     }
46588   }
46589   jresult = result;
46590   return jresult;
46591 }
46592
46593
46594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Left(void * jarg1) {
46595   unsigned int jresult ;
46596   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46597   unsigned int result;
46598
46599   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46600   {
46601     try {
46602       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Left();
46603     } catch (std::out_of_range& e) {
46604       {
46605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (std::exception& e) {
46608       {
46609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617   jresult = result;
46618   return jresult;
46619 }
46620
46621
46622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Right(void * jarg1) {
46623   unsigned int jresult ;
46624   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46625   unsigned int result;
46626
46627   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46628   {
46629     try {
46630       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Right();
46631     } catch (std::out_of_range& e) {
46632       {
46633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46634       };
46635     } catch (std::exception& e) {
46636       {
46637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46638       };
46639     } catch (...) {
46640       {
46641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46642       };
46643     }
46644   }
46645   jresult = result;
46646   return jresult;
46647 }
46648
46649
46650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Top(void * jarg1) {
46651   unsigned int jresult ;
46652   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46653   unsigned int result;
46654
46655   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46656   {
46657     try {
46658       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Top();
46659     } catch (std::out_of_range& e) {
46660       {
46661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (std::exception& e) {
46664       {
46665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46666       };
46667     } catch (...) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46670       };
46671     }
46672   }
46673   jresult = result;
46674   return jresult;
46675 }
46676
46677
46678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Bottom(void * jarg1) {
46679   unsigned int jresult ;
46680   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46681   unsigned int result;
46682
46683   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46684   {
46685     try {
46686       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Bottom();
46687     } catch (std::out_of_range& e) {
46688       {
46689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (std::exception& e) {
46692       {
46693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46694       };
46695     } catch (...) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46698       };
46699     }
46700   }
46701   jresult = result;
46702   return jresult;
46703 }
46704
46705
46706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Area(void * jarg1) {
46707   unsigned int jresult ;
46708   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46709   unsigned int result;
46710
46711   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46712   {
46713     try {
46714       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Area();
46715     } catch (std::out_of_range& e) {
46716       {
46717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46718       };
46719     } catch (std::exception& e) {
46720       {
46721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46722       };
46723     } catch (...) {
46724       {
46725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46726       };
46727     }
46728   }
46729   jresult = result;
46730   return jresult;
46731 }
46732
46733
46734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Intersects(void * jarg1, void * jarg2) {
46735   unsigned int jresult ;
46736   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46737   Dali::Rect< unsigned int > *arg2 = 0 ;
46738   bool result;
46739
46740   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46741   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46742   if (!arg2) {
46743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46744     return 0;
46745   }
46746   {
46747     try {
46748       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Intersects((Dali::Rect< unsigned int > const &)*arg2);
46749     } catch (std::out_of_range& e) {
46750       {
46751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46752       };
46753     } catch (std::exception& e) {
46754       {
46755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46756       };
46757     } catch (...) {
46758       {
46759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46760       };
46761     }
46762   }
46763   jresult = result;
46764   return jresult;
46765 }
46766
46767
46768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_Contains(void * jarg1, void * jarg2) {
46769   unsigned int jresult ;
46770   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46771   Dali::Rect< unsigned int > *arg2 = 0 ;
46772   bool result;
46773
46774   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46775   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46776   if (!arg2) {
46777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46778     return 0;
46779   }
46780   {
46781     try {
46782       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Contains((Dali::Rect< unsigned int > const &)*arg2);
46783     } catch (std::out_of_range& e) {
46784       {
46785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46786       };
46787     } catch (std::exception& e) {
46788       {
46789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46794       };
46795     }
46796   }
46797   jresult = result;
46798   return jresult;
46799 }
46800
46801
46802 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_x_set(void * jarg1, unsigned int jarg2) {
46803   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46804   unsigned int arg2 ;
46805
46806   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46807   arg2 = (unsigned int)jarg2;
46808   if (arg1) (arg1)->x = arg2;
46809 }
46810
46811
46812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_x_get(void * jarg1) {
46813   unsigned int jresult ;
46814   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46815   unsigned int result;
46816
46817   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46818   result = (unsigned int) ((arg1)->x);
46819   jresult = result;
46820   return jresult;
46821 }
46822
46823
46824 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_left_set(void * jarg1, unsigned int jarg2) {
46825   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46826   unsigned int arg2 ;
46827
46828   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46829   arg2 = (unsigned int)jarg2;
46830   if (arg1) (arg1)->left = arg2;
46831 }
46832
46833
46834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_left_get(void * jarg1) {
46835   unsigned int jresult ;
46836   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46837   unsigned int result;
46838
46839   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46840   result = (unsigned int) ((arg1)->left);
46841   jresult = result;
46842   return jresult;
46843 }
46844
46845
46846 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_y_set(void * jarg1, unsigned int jarg2) {
46847   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46848   unsigned int arg2 ;
46849
46850   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46851   arg2 = (unsigned int)jarg2;
46852   if (arg1) (arg1)->y = arg2;
46853 }
46854
46855
46856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_y_get(void * jarg1) {
46857   unsigned int jresult ;
46858   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46859   unsigned int result;
46860
46861   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46862   result = (unsigned int) ((arg1)->y);
46863   jresult = result;
46864   return jresult;
46865 }
46866
46867
46868 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_right_set(void * jarg1, unsigned int jarg2) {
46869   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46870   unsigned int arg2 ;
46871
46872   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46873   arg2 = (unsigned int)jarg2;
46874   if (arg1) (arg1)->right = arg2;
46875 }
46876
46877
46878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_right_get(void * jarg1) {
46879   unsigned int jresult ;
46880   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46881   unsigned int result;
46882
46883   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46884   result = (unsigned int) ((arg1)->right);
46885   jresult = result;
46886   return jresult;
46887 }
46888
46889
46890 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_width_set(void * jarg1, unsigned int jarg2) {
46891   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46892   unsigned int arg2 ;
46893
46894   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46895   arg2 = (unsigned int)jarg2;
46896   if (arg1) (arg1)->width = arg2;
46897 }
46898
46899
46900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_width_get(void * jarg1) {
46901   unsigned int jresult ;
46902   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46903   unsigned int result;
46904
46905   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46906   result = (unsigned int) ((arg1)->width);
46907   jresult = result;
46908   return jresult;
46909 }
46910
46911
46912 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_bottom_set(void * jarg1, unsigned int jarg2) {
46913   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46914   unsigned int arg2 ;
46915
46916   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46917   arg2 = (unsigned int)jarg2;
46918   if (arg1) (arg1)->bottom = arg2;
46919 }
46920
46921
46922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_bottom_get(void * jarg1) {
46923   unsigned int jresult ;
46924   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46925   unsigned int result;
46926
46927   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46928   result = (unsigned int) ((arg1)->bottom);
46929   jresult = result;
46930   return jresult;
46931 }
46932
46933
46934 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_height_set(void * jarg1, unsigned int jarg2) {
46935   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46936   unsigned int arg2 ;
46937
46938   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46939   arg2 = (unsigned int)jarg2;
46940   if (arg1) (arg1)->height = arg2;
46941 }
46942
46943
46944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_height_get(void * jarg1) {
46945   unsigned int jresult ;
46946   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46947   unsigned int result;
46948
46949   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46950   result = (unsigned int) ((arg1)->height);
46951   jresult = result;
46952   return jresult;
46953 }
46954
46955
46956 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_top_set(void * jarg1, unsigned int jarg2) {
46957   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46958   unsigned int arg2 ;
46959
46960   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46961   arg2 = (unsigned int)jarg2;
46962   if (arg1) (arg1)->top = arg2;
46963 }
46964
46965
46966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectUnsignedInteger_top_get(void * jarg1) {
46967   unsigned int jresult ;
46968   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46969   unsigned int result;
46970
46971   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46972   result = (unsigned int) ((arg1)->top);
46973   jresult = result;
46974   return jresult;
46975 }
46976
46977
46978 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectUnsignedInteger(void * jarg1) {
46979   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46980
46981   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46982   {
46983     try {
46984       delete arg1;
46985     } catch (std::out_of_range& e) {
46986       {
46987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46988       };
46989     } catch (std::exception& e) {
46990       {
46991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46992       };
46993     } catch (...) {
46994       {
46995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46996       };
46997     }
46998   }
46999 }
47000
47001
47002 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_0() {
47003   void * jresult ;
47004   Dali::Rect< float > *result = 0 ;
47005
47006   {
47007     try {
47008       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47009     } catch (std::out_of_range& e) {
47010       {
47011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (std::exception& e) {
47014       {
47015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (...) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47020       };
47021     }
47022   }
47023   jresult = (void *)result;
47024   return jresult;
47025 }
47026
47027
47028 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47029   void * jresult ;
47030   float arg1 ;
47031   float arg2 ;
47032   float arg3 ;
47033   float arg4 ;
47034   Dali::Rect< float > *result = 0 ;
47035
47036   arg1 = (float)jarg1;
47037   arg2 = (float)jarg2;
47038   arg3 = (float)jarg3;
47039   arg4 = (float)jarg4;
47040   {
47041     try {
47042       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47043     } catch (std::out_of_range& e) {
47044       {
47045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47046       };
47047     } catch (std::exception& e) {
47048       {
47049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47050       };
47051     } catch (...) {
47052       {
47053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47054       };
47055     }
47056   }
47057   jresult = (void *)result;
47058   return jresult;
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RectFloat__SWIG_2(void * jarg1) {
47063   void * jresult ;
47064   Dali::Rect< float > *arg1 = 0 ;
47065   Dali::Rect< float > *result = 0 ;
47066
47067   arg1 = (Dali::Rect< float > *)jarg1;
47068   if (!arg1) {
47069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47070     return 0;
47071   }
47072   {
47073     try {
47074       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47075     } catch (std::out_of_range& e) {
47076       {
47077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (std::exception& e) {
47080       {
47081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47082       };
47083     } catch (...) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47086       };
47087     }
47088   }
47089   jresult = (void *)result;
47090   return jresult;
47091 }
47092
47093
47094 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RectFloat_Assign(void * jarg1, void * jarg2) {
47095   void * jresult ;
47096   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47097   Dali::Rect< float > *arg2 = 0 ;
47098   Dali::Rect< float > *result = 0 ;
47099
47100   arg1 = (Dali::Rect< float > *)jarg1;
47101   arg2 = (Dali::Rect< float > *)jarg2;
47102   if (!arg2) {
47103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47104     return 0;
47105   }
47106   {
47107     try {
47108       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47109     } catch (std::out_of_range& e) {
47110       {
47111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (std::exception& e) {
47114       {
47115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123   jresult = (void *)result;
47124   return jresult;
47125 }
47126
47127
47128 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47129   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47130   float arg2 ;
47131   float arg3 ;
47132   float arg4 ;
47133   float arg5 ;
47134
47135   arg1 = (Dali::Rect< float > *)jarg1;
47136   arg2 = (float)jarg2;
47137   arg3 = (float)jarg3;
47138   arg4 = (float)jarg4;
47139   arg5 = (float)jarg5;
47140   {
47141     try {
47142       (arg1)->Set(arg2,arg3,arg4,arg5);
47143     } catch (std::out_of_range& e) {
47144       {
47145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47146       };
47147     } catch (std::exception& e) {
47148       {
47149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47150       };
47151     } catch (...) {
47152       {
47153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47154       };
47155     }
47156   }
47157 }
47158
47159
47160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_IsEmpty(void * jarg1) {
47161   unsigned int jresult ;
47162   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47163   bool result;
47164
47165   arg1 = (Dali::Rect< float > *)jarg1;
47166   {
47167     try {
47168       result = (bool)((Dali::Rect< float > const *)arg1)->IsEmpty();
47169     } catch (std::out_of_range& e) {
47170       {
47171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47172       };
47173     } catch (std::exception& e) {
47174       {
47175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47176       };
47177     } catch (...) {
47178       {
47179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47180       };
47181     }
47182   }
47183   jresult = result;
47184   return jresult;
47185 }
47186
47187
47188 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Left(void * jarg1) {
47189   float jresult ;
47190   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47191   float result;
47192
47193   arg1 = (Dali::Rect< float > *)jarg1;
47194   {
47195     try {
47196       result = (float)((Dali::Rect< float > const *)arg1)->Left();
47197     } catch (std::out_of_range& e) {
47198       {
47199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47200       };
47201     } catch (std::exception& e) {
47202       {
47203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47204       };
47205     } catch (...) {
47206       {
47207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47208       };
47209     }
47210   }
47211   jresult = result;
47212   return jresult;
47213 }
47214
47215
47216 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Right(void * jarg1) {
47217   float jresult ;
47218   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47219   float result;
47220
47221   arg1 = (Dali::Rect< float > *)jarg1;
47222   {
47223     try {
47224       result = (float)((Dali::Rect< float > const *)arg1)->Right();
47225     } catch (std::out_of_range& e) {
47226       {
47227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47228       };
47229     } catch (std::exception& e) {
47230       {
47231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47232       };
47233     } catch (...) {
47234       {
47235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47236       };
47237     }
47238   }
47239   jresult = result;
47240   return jresult;
47241 }
47242
47243
47244 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Top(void * jarg1) {
47245   float jresult ;
47246   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47247   float result;
47248
47249   arg1 = (Dali::Rect< float > *)jarg1;
47250   {
47251     try {
47252       result = (float)((Dali::Rect< float > const *)arg1)->Top();
47253     } catch (std::out_of_range& e) {
47254       {
47255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47256       };
47257     } catch (std::exception& e) {
47258       {
47259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47260       };
47261     } catch (...) {
47262       {
47263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47264       };
47265     }
47266   }
47267   jresult = result;
47268   return jresult;
47269 }
47270
47271
47272 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Bottom(void * jarg1) {
47273   float jresult ;
47274   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47275   float result;
47276
47277   arg1 = (Dali::Rect< float > *)jarg1;
47278   {
47279     try {
47280       result = (float)((Dali::Rect< float > const *)arg1)->Bottom();
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (...) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47292       };
47293     }
47294   }
47295   jresult = result;
47296   return jresult;
47297 }
47298
47299
47300 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_Area(void * jarg1) {
47301   float jresult ;
47302   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47303   float result;
47304
47305   arg1 = (Dali::Rect< float > *)jarg1;
47306   {
47307     try {
47308       result = (float)((Dali::Rect< float > const *)arg1)->Area();
47309     } catch (std::out_of_range& e) {
47310       {
47311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (std::exception& e) {
47314       {
47315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47320       };
47321     }
47322   }
47323   jresult = result;
47324   return jresult;
47325 }
47326
47327
47328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_Intersects(void * jarg1, void * jarg2) {
47329   unsigned int jresult ;
47330   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47331   Dali::Rect< float > *arg2 = 0 ;
47332   bool result;
47333
47334   arg1 = (Dali::Rect< float > *)jarg1;
47335   arg2 = (Dali::Rect< float > *)jarg2;
47336   if (!arg2) {
47337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47338     return 0;
47339   }
47340   {
47341     try {
47342       result = (bool)((Dali::Rect< float > const *)arg1)->Intersects((Dali::Rect< float > const &)*arg2);
47343     } catch (std::out_of_range& e) {
47344       {
47345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47346       };
47347     } catch (std::exception& e) {
47348       {
47349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47350       };
47351     } catch (...) {
47352       {
47353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47354       };
47355     }
47356   }
47357   jresult = result;
47358   return jresult;
47359 }
47360
47361
47362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RectFloat_Contains(void * jarg1, void * jarg2) {
47363   unsigned int jresult ;
47364   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47365   Dali::Rect< float > *arg2 = 0 ;
47366   bool result;
47367
47368   arg1 = (Dali::Rect< float > *)jarg1;
47369   arg2 = (Dali::Rect< float > *)jarg2;
47370   if (!arg2) {
47371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47372     return 0;
47373   }
47374   {
47375     try {
47376       result = (bool)((Dali::Rect< float > const *)arg1)->Contains((Dali::Rect< float > const &)*arg2);
47377     } catch (std::out_of_range& e) {
47378       {
47379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47380       };
47381     } catch (std::exception& e) {
47382       {
47383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47384       };
47385     } catch (...) {
47386       {
47387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47388       };
47389     }
47390   }
47391   jresult = result;
47392   return jresult;
47393 }
47394
47395
47396 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_x_set(void * jarg1, float jarg2) {
47397   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47398   float arg2 ;
47399
47400   arg1 = (Dali::Rect< float > *)jarg1;
47401   arg2 = (float)jarg2;
47402   if (arg1) (arg1)->x = arg2;
47403 }
47404
47405
47406 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_x_get(void * jarg1) {
47407   float jresult ;
47408   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47409   float result;
47410
47411   arg1 = (Dali::Rect< float > *)jarg1;
47412   result = (float) ((arg1)->x);
47413   jresult = result;
47414   return jresult;
47415 }
47416
47417
47418 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_left_set(void * jarg1, float jarg2) {
47419   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47420   float arg2 ;
47421
47422   arg1 = (Dali::Rect< float > *)jarg1;
47423   arg2 = (float)jarg2;
47424   if (arg1) (arg1)->left = arg2;
47425 }
47426
47427
47428 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_left_get(void * jarg1) {
47429   float jresult ;
47430   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47431   float result;
47432
47433   arg1 = (Dali::Rect< float > *)jarg1;
47434   result = (float) ((arg1)->left);
47435   jresult = result;
47436   return jresult;
47437 }
47438
47439
47440 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_y_set(void * jarg1, float jarg2) {
47441   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47442   float arg2 ;
47443
47444   arg1 = (Dali::Rect< float > *)jarg1;
47445   arg2 = (float)jarg2;
47446   if (arg1) (arg1)->y = arg2;
47447 }
47448
47449
47450 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_y_get(void * jarg1) {
47451   float jresult ;
47452   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47453   float result;
47454
47455   arg1 = (Dali::Rect< float > *)jarg1;
47456   result = (float) ((arg1)->y);
47457   jresult = result;
47458   return jresult;
47459 }
47460
47461
47462 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_right_set(void * jarg1, float jarg2) {
47463   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47464   float arg2 ;
47465
47466   arg1 = (Dali::Rect< float > *)jarg1;
47467   arg2 = (float)jarg2;
47468   if (arg1) (arg1)->right = arg2;
47469 }
47470
47471
47472 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_right_get(void * jarg1) {
47473   float jresult ;
47474   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47475   float result;
47476
47477   arg1 = (Dali::Rect< float > *)jarg1;
47478   result = (float) ((arg1)->right);
47479   jresult = result;
47480   return jresult;
47481 }
47482
47483
47484 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_width_set(void * jarg1, float jarg2) {
47485   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47486   float arg2 ;
47487
47488   arg1 = (Dali::Rect< float > *)jarg1;
47489   arg2 = (float)jarg2;
47490   if (arg1) (arg1)->width = arg2;
47491 }
47492
47493
47494 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_width_get(void * jarg1) {
47495   float jresult ;
47496   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47497   float result;
47498
47499   arg1 = (Dali::Rect< float > *)jarg1;
47500   result = (float) ((arg1)->width);
47501   jresult = result;
47502   return jresult;
47503 }
47504
47505
47506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_bottom_set(void * jarg1, float jarg2) {
47507   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47508   float arg2 ;
47509
47510   arg1 = (Dali::Rect< float > *)jarg1;
47511   arg2 = (float)jarg2;
47512   if (arg1) (arg1)->bottom = arg2;
47513 }
47514
47515
47516 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_bottom_get(void * jarg1) {
47517   float jresult ;
47518   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47519   float result;
47520
47521   arg1 = (Dali::Rect< float > *)jarg1;
47522   result = (float) ((arg1)->bottom);
47523   jresult = result;
47524   return jresult;
47525 }
47526
47527
47528 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_height_set(void * jarg1, float jarg2) {
47529   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47530   float arg2 ;
47531
47532   arg1 = (Dali::Rect< float > *)jarg1;
47533   arg2 = (float)jarg2;
47534   if (arg1) (arg1)->height = arg2;
47535 }
47536
47537
47538 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_height_get(void * jarg1) {
47539   float jresult ;
47540   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47541   float result;
47542
47543   arg1 = (Dali::Rect< float > *)jarg1;
47544   result = (float) ((arg1)->height);
47545   jresult = result;
47546   return jresult;
47547 }
47548
47549
47550 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RectFloat_top_set(void * jarg1, float jarg2) {
47551   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47552   float arg2 ;
47553
47554   arg1 = (Dali::Rect< float > *)jarg1;
47555   arg2 = (float)jarg2;
47556   if (arg1) (arg1)->top = arg2;
47557 }
47558
47559
47560 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RectFloat_top_get(void * jarg1) {
47561   float jresult ;
47562   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47563   float result;
47564
47565   arg1 = (Dali::Rect< float > *)jarg1;
47566   result = (float) ((arg1)->top);
47567   jresult = result;
47568   return jresult;
47569 }
47570
47571
47572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RectFloat(void * jarg1) {
47573   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47574
47575   arg1 = (Dali::Rect< float > *)jarg1;
47576   {
47577     try {
47578       delete arg1;
47579     } catch (std::out_of_range& e) {
47580       {
47581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47582       };
47583     } catch (std::exception& e) {
47584       {
47585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47586       };
47587     } catch (...) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47590       };
47591     }
47592   }
47593 }
47594
47595
47596 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorInteger_BaseType_get() {
47597   int jresult ;
47598   int result;
47599
47600   result = (int)Dali::Vector< int >::BaseType;
47601   jresult = (int)result;
47602   return jresult;
47603 }
47604
47605
47606 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorInteger__SWIG_0() {
47607   void * jresult ;
47608   Dali::Vector< int > *result = 0 ;
47609
47610   {
47611     try {
47612       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47613     } catch (std::out_of_range& e) {
47614       {
47615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47616       };
47617     } catch (std::exception& e) {
47618       {
47619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47620       };
47621     } catch (...) {
47622       {
47623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47624       };
47625     }
47626   }
47627   jresult = (void *)result;
47628   return jresult;
47629 }
47630
47631
47632 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorInteger(void * jarg1) {
47633   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47634
47635   arg1 = (Dali::Vector< int > *)jarg1;
47636   {
47637     try {
47638       delete arg1;
47639     } catch (std::out_of_range& e) {
47640       {
47641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47642       };
47643     } catch (std::exception& e) {
47644       {
47645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47646       };
47647     } catch (...) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47650       };
47651     }
47652   }
47653 }
47654
47655
47656 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorInteger__SWIG_1(void * jarg1) {
47657   void * jresult ;
47658   Dali::Vector< int > *arg1 = 0 ;
47659   Dali::Vector< int > *result = 0 ;
47660
47661   arg1 = (Dali::Vector< int > *)jarg1;
47662   if (!arg1) {
47663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47664     return 0;
47665   }
47666   {
47667     try {
47668       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47669     } catch (std::out_of_range& e) {
47670       {
47671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47672       };
47673     } catch (std::exception& e) {
47674       {
47675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47676       };
47677     } catch (...) {
47678       {
47679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47680       };
47681     }
47682   }
47683   jresult = (void *)result;
47684   return jresult;
47685 }
47686
47687
47688 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Assign(void * jarg1, void * jarg2) {
47689   void * jresult ;
47690   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47691   Dali::Vector< int > *arg2 = 0 ;
47692   Dali::Vector< int > *result = 0 ;
47693
47694   arg1 = (Dali::Vector< int > *)jarg1;
47695   arg2 = (Dali::Vector< int > *)jarg2;
47696   if (!arg2) {
47697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47698     return 0;
47699   }
47700   {
47701     try {
47702       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47703     } catch (std::out_of_range& e) {
47704       {
47705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (std::exception& e) {
47708       {
47709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (...) {
47712       {
47713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47714       };
47715     }
47716   }
47717   jresult = (void *)result;
47718   return jresult;
47719 }
47720
47721
47722 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Begin(void * jarg1) {
47723   void * jresult ;
47724   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47725   Dali::Vector< int >::Iterator result;
47726
47727   arg1 = (Dali::Vector< int > *)jarg1;
47728   {
47729     try {
47730       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47731     } catch (std::out_of_range& e) {
47732       {
47733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47734       };
47735     } catch (std::exception& e) {
47736       {
47737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47738       };
47739     } catch (...) {
47740       {
47741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47742       };
47743     }
47744   }
47745   jresult = (void *)result;
47746   return jresult;
47747 }
47748
47749
47750 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_End(void * jarg1) {
47751   void * jresult ;
47752   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47753   Dali::Vector< int >::Iterator result;
47754
47755   arg1 = (Dali::Vector< int > *)jarg1;
47756   {
47757     try {
47758       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47759     } catch (std::out_of_range& e) {
47760       {
47761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47762       };
47763     } catch (std::exception& e) {
47764       {
47765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47766       };
47767     } catch (...) {
47768       {
47769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47770       };
47771     }
47772   }
47773   jresult = (void *)result;
47774   return jresult;
47775 }
47776
47777
47778 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47779   void * jresult ;
47780   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47781   Dali::Vector< int >::SizeType arg2 ;
47782   Dali::Vector< int >::ItemType *result = 0 ;
47783
47784   arg1 = (Dali::Vector< int > *)jarg1;
47785   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47786   {
47787     try {
47788       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47789     } catch (std::out_of_range& e) {
47790       {
47791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47792       };
47793     } catch (std::exception& e) {
47794       {
47795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47796       };
47797     } catch (...) {
47798       {
47799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47800       };
47801     }
47802   }
47803   jresult = (void *)result;
47804   return jresult;
47805 }
47806
47807
47808 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_PushBack(void * jarg1, int jarg2) {
47809   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47810   Dali::Vector< int >::ItemType *arg2 = 0 ;
47811   Dali::Vector< int >::ItemType temp2 ;
47812
47813   arg1 = (Dali::Vector< int > *)jarg1;
47814   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47815   arg2 = &temp2;
47816   {
47817     try {
47818       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47819     } catch (std::out_of_range& e) {
47820       {
47821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47822       };
47823     } catch (std::exception& e) {
47824       {
47825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47826       };
47827     } catch (...) {
47828       {
47829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47830       };
47831     }
47832   }
47833 }
47834
47835
47836 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47837   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47838   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47839   Dali::Vector< int >::ItemType *arg3 = 0 ;
47840   Dali::Vector< int >::ItemType temp3 ;
47841
47842   arg1 = (Dali::Vector< int > *)jarg1;
47843   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47844   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47845   arg3 = &temp3;
47846   {
47847     try {
47848       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47856       };
47857     } catch (...) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47860       };
47861     }
47862   }
47863 }
47864
47865
47866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47867   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47868   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47869   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47870   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47871
47872   arg1 = (Dali::Vector< int > *)jarg1;
47873   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47874   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47875   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47876   {
47877     try {
47878       (arg1)->Insert(arg2,arg3,arg4);
47879     } catch (std::out_of_range& e) {
47880       {
47881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47882       };
47883     } catch (std::exception& e) {
47884       {
47885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47886       };
47887     } catch (...) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47890       };
47891     }
47892   }
47893 }
47894
47895
47896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47897   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47898   Dali::Vector< int >::SizeType arg2 ;
47899
47900   arg1 = (Dali::Vector< int > *)jarg1;
47901   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47902   {
47903     try {
47904       (arg1)->Reserve(arg2);
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47912       };
47913     } catch (...) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47916       };
47917     }
47918   }
47919 }
47920
47921
47922 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47923   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47924   Dali::Vector< int >::SizeType arg2 ;
47925
47926   arg1 = (Dali::Vector< int > *)jarg1;
47927   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47928   {
47929     try {
47930       (arg1)->Resize(arg2);
47931     } catch (std::out_of_range& e) {
47932       {
47933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47934       };
47935     } catch (std::exception& e) {
47936       {
47937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47938       };
47939     } catch (...) {
47940       {
47941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47942       };
47943     }
47944   }
47945 }
47946
47947
47948 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47949   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47950   Dali::Vector< int >::SizeType arg2 ;
47951   Dali::Vector< int >::ItemType *arg3 = 0 ;
47952   Dali::Vector< int >::ItemType temp3 ;
47953
47954   arg1 = (Dali::Vector< int > *)jarg1;
47955   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47956   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47957   arg3 = &temp3;
47958   {
47959     try {
47960       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47961     } catch (std::out_of_range& e) {
47962       {
47963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47964       };
47965     } catch (std::exception& e) {
47966       {
47967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47968       };
47969     } catch (...) {
47970       {
47971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47972       };
47973     }
47974   }
47975 }
47976
47977
47978 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
47979   void * jresult ;
47980   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47981   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47982   Dali::Vector< int >::Iterator result;
47983
47984   arg1 = (Dali::Vector< int > *)jarg1;
47985   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47986   {
47987     try {
47988       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
47989     } catch (std::out_of_range& e) {
47990       {
47991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47992       };
47993     } catch (std::exception& e) {
47994       {
47995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47996       };
47997     } catch (...) {
47998       {
47999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48000       };
48001     }
48002   }
48003   jresult = (void *)result;
48004   return jresult;
48005 }
48006
48007
48008 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48009   void * jresult ;
48010   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48011   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48012   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48013   Dali::Vector< int >::Iterator result;
48014
48015   arg1 = (Dali::Vector< int > *)jarg1;
48016   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48017   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48018   {
48019     try {
48020       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48021     } catch (std::out_of_range& e) {
48022       {
48023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48024       };
48025     } catch (std::exception& e) {
48026       {
48027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48028       };
48029     } catch (...) {
48030       {
48031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48032       };
48033     }
48034   }
48035   jresult = (void *)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Remove(void * jarg1, void * jarg2) {
48041   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48042   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48043
48044   arg1 = (Dali::Vector< int > *)jarg1;
48045   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48046   {
48047     try {
48048       (arg1)->Remove(arg2);
48049     } catch (std::out_of_range& e) {
48050       {
48051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (std::exception& e) {
48054       {
48055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48056       };
48057     } catch (...) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48060       };
48061     }
48062   }
48063 }
48064
48065
48066 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Swap(void * jarg1, void * jarg2) {
48067   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48068   Dali::Vector< int > *arg2 = 0 ;
48069
48070   arg1 = (Dali::Vector< int > *)jarg1;
48071   arg2 = (Dali::Vector< int > *)jarg2;
48072   if (!arg2) {
48073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48074     return ;
48075   }
48076   {
48077     try {
48078       (arg1)->Swap(*arg2);
48079     } catch (std::out_of_range& e) {
48080       {
48081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48082       };
48083     } catch (std::exception& e) {
48084       {
48085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48086       };
48087     } catch (...) {
48088       {
48089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48090       };
48091     }
48092   }
48093 }
48094
48095
48096 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Clear(void * jarg1) {
48097   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48098
48099   arg1 = (Dali::Vector< int > *)jarg1;
48100   {
48101     try {
48102       (arg1)->Clear();
48103     } catch (std::out_of_range& e) {
48104       {
48105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48106       };
48107     } catch (std::exception& e) {
48108       {
48109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48110       };
48111     } catch (...) {
48112       {
48113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48114       };
48115     }
48116   }
48117 }
48118
48119
48120 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorInteger_Release(void * jarg1) {
48121   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48122
48123   arg1 = (Dali::Vector< int > *)jarg1;
48124   {
48125     try {
48126       (arg1)->Release();
48127     } catch (std::out_of_range& e) {
48128       {
48129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48130       };
48131     } catch (std::exception& e) {
48132       {
48133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48134       };
48135     } catch (...) {
48136       {
48137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48138       };
48139     }
48140   }
48141 }
48142
48143
48144 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorFloat_BaseType_get() {
48145   int jresult ;
48146   int result;
48147
48148   result = (int)Dali::Vector< float >::BaseType;
48149   jresult = (int)result;
48150   return jresult;
48151 }
48152
48153
48154 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorFloat__SWIG_0() {
48155   void * jresult ;
48156   Dali::Vector< float > *result = 0 ;
48157
48158   {
48159     try {
48160       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48161     } catch (std::out_of_range& e) {
48162       {
48163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48164       };
48165     } catch (std::exception& e) {
48166       {
48167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48168       };
48169     } catch (...) {
48170       {
48171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48172       };
48173     }
48174   }
48175   jresult = (void *)result;
48176   return jresult;
48177 }
48178
48179
48180 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorFloat(void * jarg1) {
48181   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48182
48183   arg1 = (Dali::Vector< float > *)jarg1;
48184   {
48185     try {
48186       delete arg1;
48187     } catch (std::out_of_range& e) {
48188       {
48189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48190       };
48191     } catch (std::exception& e) {
48192       {
48193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48194       };
48195     } catch (...) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48198       };
48199     }
48200   }
48201 }
48202
48203
48204 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorFloat__SWIG_1(void * jarg1) {
48205   void * jresult ;
48206   Dali::Vector< float > *arg1 = 0 ;
48207   Dali::Vector< float > *result = 0 ;
48208
48209   arg1 = (Dali::Vector< float > *)jarg1;
48210   if (!arg1) {
48211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48212     return 0;
48213   }
48214   {
48215     try {
48216       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48217     } catch (std::out_of_range& e) {
48218       {
48219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48220       };
48221     } catch (std::exception& e) {
48222       {
48223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48224       };
48225     } catch (...) {
48226       {
48227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48228       };
48229     }
48230   }
48231   jresult = (void *)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Assign(void * jarg1, void * jarg2) {
48237   void * jresult ;
48238   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48239   Dali::Vector< float > *arg2 = 0 ;
48240   Dali::Vector< float > *result = 0 ;
48241
48242   arg1 = (Dali::Vector< float > *)jarg1;
48243   arg2 = (Dali::Vector< float > *)jarg2;
48244   if (!arg2) {
48245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48246     return 0;
48247   }
48248   {
48249     try {
48250       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48251     } catch (std::out_of_range& e) {
48252       {
48253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48254       };
48255     } catch (std::exception& e) {
48256       {
48257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48258       };
48259     } catch (...) {
48260       {
48261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48262       };
48263     }
48264   }
48265   jresult = (void *)result;
48266   return jresult;
48267 }
48268
48269
48270 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Begin(void * jarg1) {
48271   void * jresult ;
48272   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48273   Dali::Vector< float >::Iterator result;
48274
48275   arg1 = (Dali::Vector< float > *)jarg1;
48276   {
48277     try {
48278       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48279     } catch (std::out_of_range& e) {
48280       {
48281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48282       };
48283     } catch (std::exception& e) {
48284       {
48285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48286       };
48287     } catch (...) {
48288       {
48289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48290       };
48291     }
48292   }
48293   jresult = (void *)result;
48294   return jresult;
48295 }
48296
48297
48298 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_End(void * jarg1) {
48299   void * jresult ;
48300   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48301   Dali::Vector< float >::Iterator result;
48302
48303   arg1 = (Dali::Vector< float > *)jarg1;
48304   {
48305     try {
48306       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48318       };
48319     }
48320   }
48321   jresult = (void *)result;
48322   return jresult;
48323 }
48324
48325
48326 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48327   void * jresult ;
48328   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48329   Dali::Vector< float >::SizeType arg2 ;
48330   Dali::Vector< float >::ItemType *result = 0 ;
48331
48332   arg1 = (Dali::Vector< float > *)jarg1;
48333   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48334   {
48335     try {
48336       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48337     } catch (std::out_of_range& e) {
48338       {
48339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48340       };
48341     } catch (std::exception& e) {
48342       {
48343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48344       };
48345     } catch (...) {
48346       {
48347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48348       };
48349     }
48350   }
48351   jresult = (void *)result;
48352   return jresult;
48353 }
48354
48355
48356 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_PushBack(void * jarg1, float jarg2) {
48357   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48358   Dali::Vector< float >::ItemType *arg2 = 0 ;
48359   Dali::Vector< float >::ItemType temp2 ;
48360
48361   arg1 = (Dali::Vector< float > *)jarg1;
48362   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48363   arg2 = &temp2;
48364   {
48365     try {
48366       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48367     } catch (std::out_of_range& e) {
48368       {
48369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48370       };
48371     } catch (std::exception& e) {
48372       {
48373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48374       };
48375     } catch (...) {
48376       {
48377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48378       };
48379     }
48380   }
48381 }
48382
48383
48384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48385   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48386   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48387   Dali::Vector< float >::ItemType *arg3 = 0 ;
48388   Dali::Vector< float >::ItemType temp3 ;
48389
48390   arg1 = (Dali::Vector< float > *)jarg1;
48391   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48392   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48393   arg3 = &temp3;
48394   {
48395     try {
48396       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48397     } catch (std::out_of_range& e) {
48398       {
48399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48400       };
48401     } catch (std::exception& e) {
48402       {
48403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48404       };
48405     } catch (...) {
48406       {
48407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48408       };
48409     }
48410   }
48411 }
48412
48413
48414 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48415   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48416   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48417   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48418   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48419
48420   arg1 = (Dali::Vector< float > *)jarg1;
48421   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48422   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48423   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48424   {
48425     try {
48426       (arg1)->Insert(arg2,arg3,arg4);
48427     } catch (std::out_of_range& e) {
48428       {
48429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48430       };
48431     } catch (std::exception& e) {
48432       {
48433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48438       };
48439     }
48440   }
48441 }
48442
48443
48444 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48445   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48446   Dali::Vector< float >::SizeType arg2 ;
48447
48448   arg1 = (Dali::Vector< float > *)jarg1;
48449   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48450   {
48451     try {
48452       (arg1)->Reserve(arg2);
48453     } catch (std::out_of_range& e) {
48454       {
48455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48456       };
48457     } catch (std::exception& e) {
48458       {
48459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48460       };
48461     } catch (...) {
48462       {
48463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48464       };
48465     }
48466   }
48467 }
48468
48469
48470 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48471   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48472   Dali::Vector< float >::SizeType arg2 ;
48473
48474   arg1 = (Dali::Vector< float > *)jarg1;
48475   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48476   {
48477     try {
48478       (arg1)->Resize(arg2);
48479     } catch (std::out_of_range& e) {
48480       {
48481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48482       };
48483     } catch (std::exception& e) {
48484       {
48485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48486       };
48487     } catch (...) {
48488       {
48489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48490       };
48491     }
48492   }
48493 }
48494
48495
48496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48497   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48498   Dali::Vector< float >::SizeType arg2 ;
48499   Dali::Vector< float >::ItemType *arg3 = 0 ;
48500   Dali::Vector< float >::ItemType temp3 ;
48501
48502   arg1 = (Dali::Vector< float > *)jarg1;
48503   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48504   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48505   arg3 = &temp3;
48506   {
48507     try {
48508       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48509     } catch (std::out_of_range& e) {
48510       {
48511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48512       };
48513     } catch (std::exception& e) {
48514       {
48515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48516       };
48517     } catch (...) {
48518       {
48519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48520       };
48521     }
48522   }
48523 }
48524
48525
48526 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48527   void * jresult ;
48528   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48529   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48530   Dali::Vector< float >::Iterator result;
48531
48532   arg1 = (Dali::Vector< float > *)jarg1;
48533   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48534   {
48535     try {
48536       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48537     } catch (std::out_of_range& e) {
48538       {
48539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48540       };
48541     } catch (std::exception& e) {
48542       {
48543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48544       };
48545     } catch (...) {
48546       {
48547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48548       };
48549     }
48550   }
48551   jresult = (void *)result;
48552   return jresult;
48553 }
48554
48555
48556 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48557   void * jresult ;
48558   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48559   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48560   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48561   Dali::Vector< float >::Iterator result;
48562
48563   arg1 = (Dali::Vector< float > *)jarg1;
48564   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48565   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48566   {
48567     try {
48568       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48569     } catch (std::out_of_range& e) {
48570       {
48571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48572       };
48573     } catch (std::exception& e) {
48574       {
48575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48576       };
48577     } catch (...) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48580       };
48581     }
48582   }
48583   jresult = (void *)result;
48584   return jresult;
48585 }
48586
48587
48588 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Remove(void * jarg1, void * jarg2) {
48589   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48590   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48591
48592   arg1 = (Dali::Vector< float > *)jarg1;
48593   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48594   {
48595     try {
48596       (arg1)->Remove(arg2);
48597     } catch (std::out_of_range& e) {
48598       {
48599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48600       };
48601     } catch (std::exception& e) {
48602       {
48603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48604       };
48605     } catch (...) {
48606       {
48607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48608       };
48609     }
48610   }
48611 }
48612
48613
48614 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Swap(void * jarg1, void * jarg2) {
48615   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48616   Dali::Vector< float > *arg2 = 0 ;
48617
48618   arg1 = (Dali::Vector< float > *)jarg1;
48619   arg2 = (Dali::Vector< float > *)jarg2;
48620   if (!arg2) {
48621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48622     return ;
48623   }
48624   {
48625     try {
48626       (arg1)->Swap(*arg2);
48627     } catch (std::out_of_range& e) {
48628       {
48629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48630       };
48631     } catch (std::exception& e) {
48632       {
48633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48634       };
48635     } catch (...) {
48636       {
48637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48638       };
48639     }
48640   }
48641 }
48642
48643
48644 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Clear(void * jarg1) {
48645   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48646
48647   arg1 = (Dali::Vector< float > *)jarg1;
48648   {
48649     try {
48650       (arg1)->Clear();
48651     } catch (std::out_of_range& e) {
48652       {
48653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48654       };
48655     } catch (std::exception& e) {
48656       {
48657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48658       };
48659     } catch (...) {
48660       {
48661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48662       };
48663     }
48664   }
48665 }
48666
48667
48668 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorFloat_Release(void * jarg1) {
48669   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48670
48671   arg1 = (Dali::Vector< float > *)jarg1;
48672   {
48673     try {
48674       (arg1)->Release();
48675     } catch (std::out_of_range& e) {
48676       {
48677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48678       };
48679     } catch (std::exception& e) {
48680       {
48681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48686       };
48687     }
48688   }
48689 }
48690
48691
48692 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_BaseType_get() {
48693   int jresult ;
48694   int result;
48695
48696   result = (int)Dali::Vector< unsigned char >::BaseType;
48697   jresult = (int)result;
48698   return jresult;
48699 }
48700
48701
48702 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUnsignedChar__SWIG_0() {
48703   void * jresult ;
48704   Dali::Vector< unsigned char > *result = 0 ;
48705
48706   {
48707     try {
48708       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48709     } catch (std::out_of_range& e) {
48710       {
48711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48712       };
48713     } catch (std::exception& e) {
48714       {
48715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48716       };
48717     } catch (...) {
48718       {
48719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48720       };
48721     }
48722   }
48723   jresult = (void *)result;
48724   return jresult;
48725 }
48726
48727
48728 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorUnsignedChar(void * jarg1) {
48729   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48730
48731   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48732   {
48733     try {
48734       delete arg1;
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48742       };
48743     } catch (...) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48746       };
48747     }
48748   }
48749 }
48750
48751
48752 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48753   void * jresult ;
48754   Dali::Vector< unsigned char > *arg1 = 0 ;
48755   Dali::Vector< unsigned char > *result = 0 ;
48756
48757   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48758   if (!arg1) {
48759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48760     return 0;
48761   }
48762   {
48763     try {
48764       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48765     } catch (std::out_of_range& e) {
48766       {
48767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48768       };
48769     } catch (std::exception& e) {
48770       {
48771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48772       };
48773     } catch (...) {
48774       {
48775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48776       };
48777     }
48778   }
48779   jresult = (void *)result;
48780   return jresult;
48781 }
48782
48783
48784 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48785   void * jresult ;
48786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48787   Dali::Vector< unsigned char > *arg2 = 0 ;
48788   Dali::Vector< unsigned char > *result = 0 ;
48789
48790   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48791   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48792   if (!arg2) {
48793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48794     return 0;
48795   }
48796   {
48797     try {
48798       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48799     } catch (std::out_of_range& e) {
48800       {
48801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48802       };
48803     } catch (std::exception& e) {
48804       {
48805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (...) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48810       };
48811     }
48812   }
48813   jresult = (void *)result;
48814   return jresult;
48815 }
48816
48817
48818 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Begin(void * jarg1) {
48819   void * jresult ;
48820   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48821   Dali::Vector< unsigned char >::Iterator result;
48822
48823   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48824   {
48825     try {
48826       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
48827     } catch (std::out_of_range& e) {
48828       {
48829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48830       };
48831     } catch (std::exception& e) {
48832       {
48833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48834       };
48835     } catch (...) {
48836       {
48837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48838       };
48839     }
48840   }
48841   jresult = (void *)result;
48842   return jresult;
48843 }
48844
48845
48846 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_End(void * jarg1) {
48847   void * jresult ;
48848   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48849   Dali::Vector< unsigned char >::Iterator result;
48850
48851   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48852   {
48853     try {
48854       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
48855     } catch (std::out_of_range& e) {
48856       {
48857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48858       };
48859     } catch (std::exception& e) {
48860       {
48861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48862       };
48863     } catch (...) {
48864       {
48865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48866       };
48867     }
48868   }
48869   jresult = (void *)result;
48870   return jresult;
48871 }
48872
48873
48874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48875   void * jresult ;
48876   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48877   Dali::Vector< unsigned char >::SizeType arg2 ;
48878   Dali::Vector< unsigned char >::ItemType *result = 0 ;
48879
48880   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48881   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48882   {
48883     try {
48884       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
48885     } catch (std::out_of_range& e) {
48886       {
48887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48888       };
48889     } catch (std::exception& e) {
48890       {
48891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48892       };
48893     } catch (...) {
48894       {
48895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48896       };
48897     }
48898   }
48899   jresult = (void *)result;
48900   return jresult;
48901 }
48902
48903
48904 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
48905   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48906   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
48907   Dali::Vector< unsigned char >::ItemType temp2 ;
48908
48909   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48910   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
48911   arg2 = &temp2;
48912   {
48913     try {
48914       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
48915     } catch (std::out_of_range& e) {
48916       {
48917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (std::exception& e) {
48920       {
48921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48922       };
48923     } catch (...) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48926       };
48927     }
48928   }
48929 }
48930
48931
48932 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
48933   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48934   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48935   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48936   Dali::Vector< unsigned char >::ItemType temp3 ;
48937
48938   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48939   arg2 = jarg2;
48940   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48941   arg3 = &temp3;
48942   {
48943     try {
48944       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48945     } catch (std::out_of_range& e) {
48946       {
48947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48948       };
48949     } catch (std::exception& e) {
48950       {
48951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48952       };
48953     } catch (...) {
48954       {
48955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48956       };
48957     }
48958   }
48959
48960
48961 }
48962
48963
48964 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
48965   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48966   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48967   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48968   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48969
48970   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48971   arg2 = jarg2;
48972   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48973   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
48974   {
48975     try {
48976       (arg1)->Insert(arg2,arg3,arg4);
48977     } catch (std::out_of_range& e) {
48978       {
48979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48980       };
48981     } catch (std::exception& e) {
48982       {
48983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48984       };
48985     } catch (...) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48988       };
48989     }
48990   }
48991
48992
48993 }
48994
48995
48996 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
48997   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48998   Dali::Vector< unsigned char >::SizeType arg2 ;
48999
49000   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49001   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49002   {
49003     try {
49004       (arg1)->Reserve(arg2);
49005     } catch (std::out_of_range& e) {
49006       {
49007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49008       };
49009     } catch (std::exception& e) {
49010       {
49011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49012       };
49013     } catch (...) {
49014       {
49015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49016       };
49017     }
49018   }
49019 }
49020
49021
49022 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49023   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49024   Dali::Vector< unsigned char >::SizeType arg2 ;
49025
49026   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49027   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49028   {
49029     try {
49030       (arg1)->Resize(arg2);
49031     } catch (std::out_of_range& e) {
49032       {
49033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49034       };
49035     } catch (std::exception& e) {
49036       {
49037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49038       };
49039     } catch (...) {
49040       {
49041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49042       };
49043     }
49044   }
49045 }
49046
49047
49048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49049   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49050   Dali::Vector< unsigned char >::SizeType arg2 ;
49051   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49052   Dali::Vector< unsigned char >::ItemType temp3 ;
49053
49054   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49055   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49056   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49057   arg3 = &temp3;
49058   {
49059     try {
49060       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49061     } catch (std::out_of_range& e) {
49062       {
49063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49064       };
49065     } catch (std::exception& e) {
49066       {
49067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49068       };
49069     } catch (...) {
49070       {
49071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49072       };
49073     }
49074   }
49075 }
49076
49077
49078 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49079   void * jresult ;
49080   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49081   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49082   Dali::Vector< unsigned char >::Iterator result;
49083
49084   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49085   arg2 = jarg2;
49086   {
49087     try {
49088       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49089     } catch (std::out_of_range& e) {
49090       {
49091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49092       };
49093     } catch (std::exception& e) {
49094       {
49095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49096       };
49097     } catch (...) {
49098       {
49099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49100       };
49101     }
49102   }
49103   jresult = (void *)result;
49104
49105
49106   return jresult;
49107 }
49108
49109
49110 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49111   void * jresult ;
49112   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49113   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49114   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49115   Dali::Vector< unsigned char >::Iterator result;
49116
49117   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49118   arg2 = jarg2;
49119   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49120   {
49121     try {
49122       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49123     } catch (std::out_of_range& e) {
49124       {
49125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49126       };
49127     } catch (std::exception& e) {
49128       {
49129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49130       };
49131     } catch (...) {
49132       {
49133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49134       };
49135     }
49136   }
49137   jresult = (void *)result;
49138
49139
49140   return jresult;
49141 }
49142
49143
49144 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49145   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49146   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49147
49148   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49149   arg2 = jarg2;
49150   {
49151     try {
49152       (arg1)->Remove(arg2);
49153     } catch (std::out_of_range& e) {
49154       {
49155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49156       };
49157     } catch (std::exception& e) {
49158       {
49159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49164       };
49165     }
49166   }
49167
49168
49169 }
49170
49171
49172 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49173   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49174   Dali::Vector< unsigned char > *arg2 = 0 ;
49175
49176   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49177   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49178   if (!arg2) {
49179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49180     return ;
49181   }
49182   {
49183     try {
49184       (arg1)->Swap(*arg2);
49185     } catch (std::out_of_range& e) {
49186       {
49187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49188       };
49189     } catch (std::exception& e) {
49190       {
49191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49192       };
49193     } catch (...) {
49194       {
49195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49196       };
49197     }
49198   }
49199 }
49200
49201
49202 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Clear(void * jarg1) {
49203   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49204
49205   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49206   {
49207     try {
49208       (arg1)->Clear();
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223 }
49224
49225
49226 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUnsignedChar_Release(void * jarg1) {
49227   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49228
49229   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49230   {
49231     try {
49232       (arg1)->Release();
49233     } catch (std::out_of_range& e) {
49234       {
49235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49236       };
49237     } catch (std::exception& e) {
49238       {
49239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49240       };
49241     } catch (...) {
49242       {
49243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49244       };
49245     }
49246   }
49247 }
49248
49249
49250 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VectorUint16Pair_BaseType_get() {
49251   int jresult ;
49252   int result;
49253
49254   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49255   jresult = (int)result;
49256   return jresult;
49257 }
49258
49259
49260 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUint16Pair__SWIG_0() {
49261   void * jresult ;
49262   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49263
49264   {
49265     try {
49266       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49267     } catch (std::out_of_range& e) {
49268       {
49269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49270       };
49271     } catch (std::exception& e) {
49272       {
49273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49274       };
49275     } catch (...) {
49276       {
49277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49278       };
49279     }
49280   }
49281   jresult = (void *)result;
49282   return jresult;
49283 }
49284
49285
49286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VectorUint16Pair(void * jarg1) {
49287   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49288
49289   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49290   {
49291     try {
49292       delete arg1;
49293     } catch (std::out_of_range& e) {
49294       {
49295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49296       };
49297     } catch (std::exception& e) {
49298       {
49299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49300       };
49301     } catch (...) {
49302       {
49303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49304       };
49305     }
49306   }
49307 }
49308
49309
49310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49311   void * jresult ;
49312   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49313   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49314
49315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49316   if (!arg1) {
49317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49318     return 0;
49319   }
49320   {
49321     try {
49322       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49323     } catch (std::out_of_range& e) {
49324       {
49325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49326       };
49327     } catch (std::exception& e) {
49328       {
49329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49330       };
49331     } catch (...) {
49332       {
49333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49334       };
49335     }
49336   }
49337   jresult = (void *)result;
49338   return jresult;
49339 }
49340
49341
49342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49343   void * jresult ;
49344   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49345   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49346   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49347
49348   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49349   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49350   if (!arg2) {
49351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49352     return 0;
49353   }
49354   {
49355     try {
49356       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49357     } catch (std::out_of_range& e) {
49358       {
49359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49360       };
49361     } catch (std::exception& e) {
49362       {
49363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49364       };
49365     } catch (...) {
49366       {
49367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49368       };
49369     }
49370   }
49371   jresult = (void *)result;
49372   return jresult;
49373 }
49374
49375
49376 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Begin(void * jarg1) {
49377   void * jresult ;
49378   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49379   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49380
49381   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49382   {
49383     try {
49384       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49385     } catch (std::out_of_range& e) {
49386       {
49387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49388       };
49389     } catch (std::exception& e) {
49390       {
49391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49396       };
49397     }
49398   }
49399   jresult = (void *)result;
49400   return jresult;
49401 }
49402
49403
49404 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_End(void * jarg1) {
49405   void * jresult ;
49406   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49407   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49408
49409   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49410   {
49411     try {
49412       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49413     } catch (std::out_of_range& e) {
49414       {
49415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49416       };
49417     } catch (std::exception& e) {
49418       {
49419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49424       };
49425     }
49426   }
49427   jresult = (void *)result;
49428   return jresult;
49429 }
49430
49431
49432 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49433   void * jresult ;
49434   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49435   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49436   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49437
49438   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49439   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49440   {
49441     try {
49442       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49443     } catch (std::out_of_range& e) {
49444       {
49445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (std::exception& e) {
49448       {
49449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49450       };
49451     } catch (...) {
49452       {
49453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49454       };
49455     }
49456   }
49457   jresult = (void *)result;
49458   return jresult;
49459 }
49460
49461
49462 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49463   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49464   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49465
49466   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49467   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49468   if (!arg2) {
49469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49470     return ;
49471   }
49472   {
49473     try {
49474       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49475     } catch (std::out_of_range& e) {
49476       {
49477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49478       };
49479     } catch (std::exception& e) {
49480       {
49481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49482       };
49483     } catch (...) {
49484       {
49485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49486       };
49487     }
49488   }
49489 }
49490
49491
49492 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49493   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49494   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49495   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49496
49497   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49498   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49499   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49500   if (!arg3) {
49501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49502     return ;
49503   }
49504   {
49505     try {
49506       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49507     } catch (std::out_of_range& e) {
49508       {
49509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49510       };
49511     } catch (std::exception& e) {
49512       {
49513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49514       };
49515     } catch (...) {
49516       {
49517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49518       };
49519     }
49520   }
49521 }
49522
49523
49524 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49525   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49526   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49527   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49528   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49529
49530   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49531   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49532   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49533   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49534   {
49535     try {
49536       (arg1)->Insert(arg2,arg3,arg4);
49537     } catch (std::out_of_range& e) {
49538       {
49539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49540       };
49541     } catch (std::exception& e) {
49542       {
49543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49544       };
49545     } catch (...) {
49546       {
49547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49548       };
49549     }
49550   }
49551 }
49552
49553
49554 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49555   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49556   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49557
49558   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49559   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49560   {
49561     try {
49562       (arg1)->Reserve(arg2);
49563     } catch (std::out_of_range& e) {
49564       {
49565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49566       };
49567     } catch (std::exception& e) {
49568       {
49569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49570       };
49571     } catch (...) {
49572       {
49573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49574       };
49575     }
49576   }
49577 }
49578
49579
49580 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49581   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49582   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49583
49584   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49585   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49586   {
49587     try {
49588       (arg1)->Resize(arg2);
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49596       };
49597     } catch (...) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49600       };
49601     }
49602   }
49603 }
49604
49605
49606 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49607   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49608   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49609   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49610
49611   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49612   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49613   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49614   if (!arg3) {
49615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49616     return ;
49617   }
49618   {
49619     try {
49620       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49621     } catch (std::out_of_range& e) {
49622       {
49623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49624       };
49625     } catch (std::exception& e) {
49626       {
49627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49628       };
49629     } catch (...) {
49630       {
49631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49632       };
49633     }
49634   }
49635 }
49636
49637
49638 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49639   void * jresult ;
49640   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49641   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49642   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49643
49644   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49645   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49646   {
49647     try {
49648       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49649     } catch (std::out_of_range& e) {
49650       {
49651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49652       };
49653     } catch (std::exception& e) {
49654       {
49655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49656       };
49657     } catch (...) {
49658       {
49659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49660       };
49661     }
49662   }
49663   jresult = (void *)result;
49664   return jresult;
49665 }
49666
49667
49668 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49669   void * jresult ;
49670   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49671   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49672   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49673   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49674
49675   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49676   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49677   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49678   {
49679     try {
49680       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
49681     } catch (std::out_of_range& e) {
49682       {
49683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49684       };
49685     } catch (std::exception& e) {
49686       {
49687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49688       };
49689     } catch (...) {
49690       {
49691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49692       };
49693     }
49694   }
49695   jresult = (void *)result;
49696   return jresult;
49697 }
49698
49699
49700 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
49701   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49702   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49703
49704   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49705   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49706   {
49707     try {
49708       (arg1)->Remove(arg2);
49709     } catch (std::out_of_range& e) {
49710       {
49711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49712       };
49713     } catch (std::exception& e) {
49714       {
49715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (...) {
49718       {
49719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49720       };
49721     }
49722   }
49723 }
49724
49725
49726 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
49727   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49728   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49729
49730   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49731   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49732   if (!arg2) {
49733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
49734     return ;
49735   }
49736   {
49737     try {
49738       (arg1)->Swap(*arg2);
49739     } catch (std::out_of_range& e) {
49740       {
49741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49742       };
49743     } catch (std::exception& e) {
49744       {
49745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49746       };
49747     } catch (...) {
49748       {
49749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49750       };
49751     }
49752   }
49753 }
49754
49755
49756 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Clear(void * jarg1) {
49757   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49758
49759   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49760   {
49761     try {
49762       (arg1)->Clear();
49763     } catch (std::out_of_range& e) {
49764       {
49765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49766       };
49767     } catch (std::exception& e) {
49768       {
49769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49770       };
49771     } catch (...) {
49772       {
49773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49774       };
49775     }
49776   }
49777 }
49778
49779
49780 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VectorUint16Pair_Release(void * jarg1) {
49781   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49782
49783   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49784   {
49785     try {
49786       (arg1)->Release();
49787     } catch (std::out_of_range& e) {
49788       {
49789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49790       };
49791     } catch (std::exception& e) {
49792       {
49793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49794       };
49795     } catch (...) {
49796       {
49797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49798       };
49799     }
49800   }
49801 }
49802
49803
49804 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VoidSignal() {
49805   void * jresult ;
49806   Dali::Signal< void () > *result = 0 ;
49807
49808   {
49809     try {
49810       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (...) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49822       };
49823     }
49824   }
49825   jresult = (void *)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VoidSignal(void * jarg1) {
49831   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49832
49833   arg1 = (Dali::Signal< void () > *)jarg1;
49834   {
49835     try {
49836       delete arg1;
49837     } catch (std::out_of_range& e) {
49838       {
49839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49840       };
49841     } catch (std::exception& e) {
49842       {
49843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49844       };
49845     } catch (...) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49848       };
49849     }
49850   }
49851 }
49852
49853
49854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VoidSignal_Empty(void * jarg1) {
49855   unsigned int jresult ;
49856   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49857   bool result;
49858
49859   arg1 = (Dali::Signal< void () > *)jarg1;
49860   {
49861     try {
49862       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
49863     } catch (std::out_of_range& e) {
49864       {
49865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49866       };
49867     } catch (std::exception& e) {
49868       {
49869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49870       };
49871     } catch (...) {
49872       {
49873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49874       };
49875     }
49876   }
49877   jresult = result;
49878   return jresult;
49879 }
49880
49881
49882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VoidSignal_GetConnectionCount(void * jarg1) {
49883   unsigned long jresult ;
49884   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49885   std::size_t result;
49886
49887   arg1 = (Dali::Signal< void () > *)jarg1;
49888   {
49889     try {
49890       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
49891     } catch (std::out_of_range& e) {
49892       {
49893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49894       };
49895     } catch (std::exception& e) {
49896       {
49897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49898       };
49899     } catch (...) {
49900       {
49901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49902       };
49903     }
49904   }
49905   jresult = (unsigned long)result;
49906   return jresult;
49907 }
49908
49909
49910 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
49911   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49912   void (*arg2)() = (void (*)()) 0 ;
49913
49914   arg1 = (Dali::Signal< void () > *)jarg1;
49915   arg2 = (void (*)())jarg2;
49916   {
49917     try {
49918       (arg1)->Connect(arg2);
49919     } catch (std::out_of_range& e) {
49920       {
49921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49922       };
49923     } catch (std::exception& e) {
49924       {
49925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49926       };
49927     } catch (...) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49930       };
49931     }
49932   }
49933 }
49934
49935
49936 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
49937   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49938   void (*arg2)() = (void (*)()) 0 ;
49939
49940   arg1 = (Dali::Signal< void () > *)jarg1;
49941   arg2 = (void (*)())jarg2;
49942   {
49943     try {
49944       (arg1)->Disconnect(arg2);
49945     } catch (std::out_of_range& e) {
49946       {
49947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49948       };
49949     } catch (std::exception& e) {
49950       {
49951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49952       };
49953     } catch (...) {
49954       {
49955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49956       };
49957     }
49958   }
49959 }
49960
49961
49962 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
49963   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49964   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
49965   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
49966
49967   arg1 = (Dali::Signal< void () > *)jarg1;
49968   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
49969   arg3 = (Dali::FunctorDelegate *)jarg3;
49970   {
49971     try {
49972       (arg1)->Connect(arg2,arg3);
49973     } catch (std::out_of_range& e) {
49974       {
49975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49976       };
49977     } catch (std::exception& e) {
49978       {
49979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49980       };
49981     } catch (...) {
49982       {
49983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49984       };
49985     }
49986   }
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VoidSignal_Emit(void * jarg1) {
49991   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49992
49993   arg1 = (Dali::Signal< void () > *)jarg1;
49994   {
49995     try {
49996       (arg1)->Emit();
49997     } catch (std::out_of_range& e) {
49998       {
49999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (std::exception& e) {
50002       {
50003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011 }
50012
50013
50014 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_BoolSignal() {
50015   void * jresult ;
50016   Dali::Signal< bool () > *result = 0 ;
50017
50018   {
50019     try {
50020       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
50021     } catch (std::out_of_range& e) {
50022       {
50023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50024       };
50025     } catch (std::exception& e) {
50026       {
50027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50028       };
50029     } catch (...) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50032       };
50033     }
50034   }
50035   jresult = (void *)result;
50036   return jresult;
50037 }
50038
50039
50040 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_BoolSignal(void * jarg1) {
50041   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50042
50043   arg1 = (Dali::Signal< bool () > *)jarg1;
50044   {
50045     try {
50046       delete arg1;
50047     } catch (std::out_of_range& e) {
50048       {
50049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50050       };
50051     } catch (std::exception& e) {
50052       {
50053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50054       };
50055     } catch (...) {
50056       {
50057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50058       };
50059     }
50060   }
50061 }
50062
50063
50064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BoolSignal_Empty(void * jarg1) {
50065   unsigned int jresult ;
50066   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50067   bool result;
50068
50069   arg1 = (Dali::Signal< bool () > *)jarg1;
50070   {
50071     try {
50072       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
50073     } catch (std::out_of_range& e) {
50074       {
50075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50076       };
50077     } catch (std::exception& e) {
50078       {
50079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50080       };
50081     } catch (...) {
50082       {
50083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50084       };
50085     }
50086   }
50087   jresult = result;
50088   return jresult;
50089 }
50090
50091
50092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_BoolSignal_GetConnectionCount(void * jarg1) {
50093   unsigned long jresult ;
50094   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50095   std::size_t result;
50096
50097   arg1 = (Dali::Signal< bool () > *)jarg1;
50098   {
50099     try {
50100       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
50101     } catch (std::out_of_range& e) {
50102       {
50103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50104       };
50105     } catch (std::exception& e) {
50106       {
50107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50108       };
50109     } catch (...) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50112       };
50113     }
50114   }
50115   jresult = (unsigned long)result;
50116   return jresult;
50117 }
50118
50119
50120 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50121   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50122   bool (*arg2)() = (bool (*)()) 0 ;
50123
50124   arg1 = (Dali::Signal< bool () > *)jarg1;
50125   arg2 = (bool (*)())jarg2;
50126   {
50127     try {
50128       (arg1)->Connect(arg2);
50129     } catch (std::out_of_range& e) {
50130       {
50131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50132       };
50133     } catch (std::exception& e) {
50134       {
50135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50136       };
50137     } catch (...) {
50138       {
50139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50140       };
50141     }
50142   }
50143 }
50144
50145
50146 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Disconnect(void * jarg1, void * jarg2) {
50147   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50148   bool (*arg2)() = (bool (*)()) 0 ;
50149
50150   arg1 = (Dali::Signal< bool () > *)jarg1;
50151   arg2 = (bool (*)())jarg2;
50152   {
50153     try {
50154       (arg1)->Disconnect(arg2);
50155     } catch (std::out_of_range& e) {
50156       {
50157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50158       };
50159     } catch (std::exception& e) {
50160       {
50161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50162       };
50163     } catch (...) {
50164       {
50165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50166       };
50167     }
50168   }
50169 }
50170
50171
50172 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_BoolSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50173   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50174   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50175   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50176
50177   arg1 = (Dali::Signal< bool () > *)jarg1;
50178   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50179   arg3 = (Dali::FunctorDelegate *)jarg3;
50180   {
50181     try {
50182       (arg1)->Connect(arg2,arg3);
50183     } catch (std::out_of_range& e) {
50184       {
50185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50186       };
50187     } catch (std::exception& e) {
50188       {
50189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50190       };
50191     } catch (...) {
50192       {
50193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50194       };
50195     }
50196   }
50197 }
50198
50199
50200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_BoolSignal_Emit(void * jarg1) {
50201   unsigned int jresult ;
50202   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50203   bool result;
50204
50205   arg1 = (Dali::Signal< bool () > *)jarg1;
50206   {
50207     try {
50208       result = (bool)(arg1)->Emit();
50209     } catch (std::out_of_range& e) {
50210       {
50211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50212       };
50213     } catch (std::exception& e) {
50214       {
50215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50216       };
50217     } catch (...) {
50218       {
50219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50220       };
50221     }
50222   }
50223   jresult = result;
50224   return jresult;
50225 }
50226
50227
50228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FloatSignal_Empty(void * jarg1) {
50229   unsigned int jresult ;
50230   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50231   bool result;
50232
50233   arg1 = (Dali::Signal< void (float) > *)jarg1;
50234   {
50235     try {
50236       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50237     } catch (std::out_of_range& e) {
50238       {
50239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50240       };
50241     } catch (std::exception& e) {
50242       {
50243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50244       };
50245     } catch (...) {
50246       {
50247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50248       };
50249     }
50250   }
50251   jresult = result;
50252   return jresult;
50253 }
50254
50255
50256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FloatSignal_GetConnectionCount(void * jarg1) {
50257   unsigned long jresult ;
50258   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50259   std::size_t result;
50260
50261   arg1 = (Dali::Signal< void (float) > *)jarg1;
50262   {
50263     try {
50264       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50265     } catch (std::out_of_range& e) {
50266       {
50267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50268       };
50269     } catch (std::exception& e) {
50270       {
50271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50272       };
50273     } catch (...) {
50274       {
50275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50276       };
50277     }
50278   }
50279   jresult = (unsigned long)result;
50280   return jresult;
50281 }
50282
50283
50284 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Connect(void * jarg1, void * jarg2) {
50285   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50286   void (*arg2)(float) = (void (*)(float)) 0 ;
50287
50288   arg1 = (Dali::Signal< void (float) > *)jarg1;
50289   arg2 = (void (*)(float))jarg2;
50290   {
50291     try {
50292       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50293     } catch (std::out_of_range& e) {
50294       {
50295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50296       };
50297     } catch (std::exception& e) {
50298       {
50299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50300       };
50301     } catch (...) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50304       };
50305     }
50306   }
50307 }
50308
50309
50310 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50311   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50312   void (*arg2)(float) = (void (*)(float)) 0 ;
50313
50314   arg1 = (Dali::Signal< void (float) > *)jarg1;
50315   arg2 = (void (*)(float))jarg2;
50316   {
50317     try {
50318       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50319     } catch (std::out_of_range& e) {
50320       {
50321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50322       };
50323     } catch (std::exception& e) {
50324       {
50325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50326       };
50327     } catch (...) {
50328       {
50329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50330       };
50331     }
50332   }
50333 }
50334
50335
50336 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FloatSignal_Emit(void * jarg1, float jarg2) {
50337   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50338   float arg2 ;
50339
50340   arg1 = (Dali::Signal< void (float) > *)jarg1;
50341   arg2 = (float)jarg2;
50342   {
50343     try {
50344       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50345     } catch (std::out_of_range& e) {
50346       {
50347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50348       };
50349     } catch (std::exception& e) {
50350       {
50351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50352       };
50353     } catch (...) {
50354       {
50355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50356       };
50357     }
50358   }
50359 }
50360
50361
50362 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FloatSignal() {
50363   void * jresult ;
50364   Dali::Signal< void (float) > *result = 0 ;
50365
50366   {
50367     try {
50368       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50369     } catch (std::out_of_range& e) {
50370       {
50371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50372       };
50373     } catch (std::exception& e) {
50374       {
50375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50376       };
50377     } catch (...) {
50378       {
50379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50380       };
50381     }
50382   }
50383   jresult = (void *)result;
50384   return jresult;
50385 }
50386
50387
50388 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FloatSignal(void * jarg1) {
50389   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50390
50391   arg1 = (Dali::Signal< void (float) > *)jarg1;
50392   {
50393     try {
50394       delete arg1;
50395     } catch (std::out_of_range& e) {
50396       {
50397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50398       };
50399     } catch (std::exception& e) {
50400       {
50401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50402       };
50403     } catch (...) {
50404       {
50405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50406       };
50407     }
50408   }
50409 }
50410
50411
50412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Empty(void * jarg1) {
50413   unsigned int jresult ;
50414   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50415   bool result;
50416
50417   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50418   {
50419     try {
50420       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50421     } catch (std::out_of_range& e) {
50422       {
50423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50424       };
50425     } catch (std::exception& e) {
50426       {
50427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50428       };
50429     } catch (...) {
50430       {
50431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50432       };
50433     }
50434   }
50435   jresult = result;
50436   return jresult;
50437 }
50438
50439
50440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50441   unsigned long jresult ;
50442   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50443   std::size_t result;
50444
50445   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50446   {
50447     try {
50448       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50449     } catch (std::out_of_range& e) {
50450       {
50451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50452       };
50453     } catch (std::exception& e) {
50454       {
50455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50460       };
50461     }
50462   }
50463   jresult = (unsigned long)result;
50464   return jresult;
50465 }
50466
50467
50468 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50469   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50470   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50471
50472   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50473   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50474   {
50475     try {
50476       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50477     } catch (std::out_of_range& e) {
50478       {
50479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50480       };
50481     } catch (std::exception& e) {
50482       {
50483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50484       };
50485     } catch (...) {
50486       {
50487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50488       };
50489     }
50490   }
50491 }
50492
50493
50494 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50495   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50496   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50497
50498   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50499   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50500   {
50501     try {
50502       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50503     } catch (std::out_of_range& e) {
50504       {
50505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50506       };
50507     } catch (std::exception& e) {
50508       {
50509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50510       };
50511     } catch (...) {
50512       {
50513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50514       };
50515     }
50516   }
50517 }
50518
50519
50520 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50521   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50522   Dali::BaseHandle arg2 ;
50523   Dali::BaseHandle *argp2 ;
50524
50525   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50526   argp2 = (Dali::BaseHandle *)jarg2;
50527   if (!argp2) {
50528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50529     return ;
50530   }
50531   arg2 = *argp2;
50532   {
50533     try {
50534       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50535     } catch (std::out_of_range& e) {
50536       {
50537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50538       };
50539     } catch (std::exception& e) {
50540       {
50541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50546       };
50547     }
50548   }
50549 }
50550
50551
50552 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectCreatedSignal() {
50553   void * jresult ;
50554   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50555
50556   {
50557     try {
50558       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50559     } catch (std::out_of_range& e) {
50560       {
50561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50562       };
50563     } catch (std::exception& e) {
50564       {
50565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50566       };
50567     } catch (...) {
50568       {
50569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50570       };
50571     }
50572   }
50573   jresult = (void *)result;
50574   return jresult;
50575 }
50576
50577
50578 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectCreatedSignal(void * jarg1) {
50579   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50580
50581   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50582   {
50583     try {
50584       delete arg1;
50585     } catch (std::out_of_range& e) {
50586       {
50587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50588       };
50589     } catch (std::exception& e) {
50590       {
50591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50592       };
50593     } catch (...) {
50594       {
50595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50596       };
50597     }
50598   }
50599 }
50600
50601
50602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Empty(void * jarg1) {
50603   unsigned int jresult ;
50604   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50605   bool result;
50606
50607   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50608   {
50609     try {
50610       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50611     } catch (std::out_of_range& e) {
50612       {
50613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50614       };
50615     } catch (std::exception& e) {
50616       {
50617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50618       };
50619     } catch (...) {
50620       {
50621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50622       };
50623     }
50624   }
50625   jresult = result;
50626   return jresult;
50627 }
50628
50629
50630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50631   unsigned long jresult ;
50632   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50633   std::size_t result;
50634
50635   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50636   {
50637     try {
50638       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50639     } catch (std::out_of_range& e) {
50640       {
50641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50642       };
50643     } catch (std::exception& e) {
50644       {
50645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50646       };
50647     } catch (...) {
50648       {
50649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50650       };
50651     }
50652   }
50653   jresult = (unsigned long)result;
50654   return jresult;
50655 }
50656
50657
50658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50659   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50660   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50661
50662   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50663   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50664   {
50665     try {
50666       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50667     } catch (std::out_of_range& e) {
50668       {
50669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50670       };
50671     } catch (std::exception& e) {
50672       {
50673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50674       };
50675     } catch (...) {
50676       {
50677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50678       };
50679     }
50680   }
50681 }
50682
50683
50684 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50685   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50686   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50687
50688   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50689   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50690   {
50691     try {
50692       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50693     } catch (std::out_of_range& e) {
50694       {
50695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50696       };
50697     } catch (std::exception& e) {
50698       {
50699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50700       };
50701     } catch (...) {
50702       {
50703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50704       };
50705     }
50706   }
50707 }
50708
50709
50710 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
50711   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50712   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
50713
50714   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50715   arg2 = (Dali::RefObject *)jarg2;
50716   {
50717     try {
50718       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
50719     } catch (std::out_of_range& e) {
50720       {
50721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50722       };
50723     } catch (std::exception& e) {
50724       {
50725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50726       };
50727     } catch (...) {
50728       {
50729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50730       };
50731     }
50732   }
50733 }
50734
50735
50736 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ObjectDestroyedSignal() {
50737   void * jresult ;
50738   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
50739
50740   {
50741     try {
50742       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
50743     } catch (std::out_of_range& e) {
50744       {
50745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50746       };
50747     } catch (std::exception& e) {
50748       {
50749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50750       };
50751     } catch (...) {
50752       {
50753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50754       };
50755     }
50756   }
50757   jresult = (void *)result;
50758   return jresult;
50759 }
50760
50761
50762 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ObjectDestroyedSignal(void * jarg1) {
50763   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50764
50765   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50766   {
50767     try {
50768       delete arg1;
50769     } catch (std::out_of_range& e) {
50770       {
50771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50772       };
50773     } catch (std::exception& e) {
50774       {
50775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50776       };
50777     } catch (...) {
50778       {
50779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50780       };
50781     }
50782   }
50783 }
50784
50785
50786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Empty(void * jarg1) {
50787   unsigned int jresult ;
50788   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50789   bool result;
50790
50791   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50792   {
50793     try {
50794       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50795     } catch (std::out_of_range& e) {
50796       {
50797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50798       };
50799     } catch (std::exception& e) {
50800       {
50801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50802       };
50803     } catch (...) {
50804       {
50805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50806       };
50807     }
50808   }
50809   jresult = result;
50810   return jresult;
50811 }
50812
50813
50814 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
50815   unsigned long jresult ;
50816   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50817   std::size_t result;
50818
50819   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50820   {
50821     try {
50822       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50823     } catch (std::out_of_range& e) {
50824       {
50825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50826       };
50827     } catch (std::exception& e) {
50828       {
50829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50830       };
50831     } catch (...) {
50832       {
50833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50834       };
50835     }
50836   }
50837   jresult = (unsigned long)result;
50838   return jresult;
50839 }
50840
50841
50842 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
50843   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50844   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50845
50846   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50847   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50848   {
50849     try {
50850       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
50851     } catch (std::out_of_range& e) {
50852       {
50853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50854       };
50855     } catch (std::exception& e) {
50856       {
50857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50858       };
50859     } catch (...) {
50860       {
50861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50862       };
50863     }
50864   }
50865 }
50866
50867
50868 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
50869   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50870   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50871
50872   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50873   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50874   {
50875     try {
50876       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
50877     } catch (std::out_of_range& e) {
50878       {
50879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50880       };
50881     } catch (std::exception& e) {
50882       {
50883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50884       };
50885     } catch (...) {
50886       {
50887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50888       };
50889     }
50890   }
50891 }
50892
50893
50894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
50895   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50896   Dali::PropertyNotification *arg2 = 0 ;
50897
50898   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50899   arg2 = (Dali::PropertyNotification *)jarg2;
50900   if (!arg2) {
50901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
50902     return ;
50903   }
50904   {
50905     try {
50906       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
50907     } catch (std::out_of_range& e) {
50908       {
50909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50910       };
50911     } catch (std::exception& e) {
50912       {
50913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50914       };
50915     } catch (...) {
50916       {
50917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50918       };
50919     }
50920   }
50921 }
50922
50923
50924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PropertyNotifySignal() {
50925   void * jresult ;
50926   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
50927
50928   {
50929     try {
50930       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
50931     } catch (std::out_of_range& e) {
50932       {
50933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50934       };
50935     } catch (std::exception& e) {
50936       {
50937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50938       };
50939     } catch (...) {
50940       {
50941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50942       };
50943     }
50944   }
50945   jresult = (void *)result;
50946   return jresult;
50947 }
50948
50949
50950 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PropertyNotifySignal(void * jarg1) {
50951   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50952
50953   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50954   {
50955     try {
50956       delete arg1;
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50964       };
50965     } catch (...) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50968       };
50969     }
50970   }
50971 }
50972
50973
50974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ImageSignal_Empty(void * jarg1) {
50975   unsigned int jresult ;
50976   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
50977   bool result;
50978
50979   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
50980   {
50981     try {
50982       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
50983     } catch (std::out_of_range& e) {
50984       {
50985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50986       };
50987     } catch (std::exception& e) {
50988       {
50989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50990       };
50991     } catch (...) {
50992       {
50993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50994       };
50995     }
50996   }
50997   jresult = result;
50998   return jresult;
50999 }
51000
51001
51002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ImageSignal_GetConnectionCount(void * jarg1) {
51003   unsigned long jresult ;
51004   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51005   std::size_t result;
51006
51007   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51008   {
51009     try {
51010       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
51011     } catch (std::out_of_range& e) {
51012       {
51013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51014       };
51015     } catch (std::exception& e) {
51016       {
51017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51018       };
51019     } catch (...) {
51020       {
51021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51022       };
51023     }
51024   }
51025   jresult = (unsigned long)result;
51026   return jresult;
51027 }
51028
51029
51030 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Connect(void * jarg1, void * jarg2) {
51031   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51032   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51033
51034   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51035   arg2 = (void (*)(Dali::Image))jarg2;
51036   {
51037     try {
51038       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
51039     } catch (std::out_of_range& e) {
51040       {
51041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51042       };
51043     } catch (std::exception& e) {
51044       {
51045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51046       };
51047     } catch (...) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51050       };
51051     }
51052   }
51053 }
51054
51055
51056 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
51057   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51058   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51059
51060   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51061   arg2 = (void (*)(Dali::Image))jarg2;
51062   {
51063     try {
51064       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51076       };
51077     }
51078   }
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageSignal_Emit(void * jarg1, void * jarg2) {
51083   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51084   Dali::Image arg2 ;
51085   Dali::Image *argp2 ;
51086
51087   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51088   argp2 = (Dali::Image *)jarg2;
51089   if (!argp2) {
51090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
51091     return ;
51092   }
51093   arg2 = *argp2;
51094   {
51095     try {
51096       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51104       };
51105     } catch (...) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51108       };
51109     }
51110   }
51111 }
51112
51113
51114 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageSignal() {
51115   void * jresult ;
51116   Dali::Signal< void (Dali::Image) > *result = 0 ;
51117
51118   {
51119     try {
51120       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51128       };
51129     } catch (...) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51132       };
51133     }
51134   }
51135   jresult = (void *)result;
51136   return jresult;
51137 }
51138
51139
51140 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageSignal(void * jarg1) {
51141   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51142
51143   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51144   {
51145     try {
51146       delete arg1;
51147     } catch (std::out_of_range& e) {
51148       {
51149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51150       };
51151     } catch (std::exception& e) {
51152       {
51153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51154       };
51155     } catch (...) {
51156       {
51157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51158       };
51159     }
51160   }
51161 }
51162
51163
51164 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RenderTaskSignal() {
51165   void * jresult ;
51166   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51167
51168   {
51169     try {
51170       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51171     } catch (std::out_of_range& e) {
51172       {
51173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51174       };
51175     } catch (std::exception& e) {
51176       {
51177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51182       };
51183     }
51184   }
51185   jresult = (void *)result;
51186   return jresult;
51187 }
51188
51189
51190 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RenderTaskSignal(void * jarg1) {
51191   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51192
51193   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51194   {
51195     try {
51196       delete arg1;
51197     } catch (std::out_of_range& e) {
51198       {
51199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51200       };
51201     } catch (std::exception& e) {
51202       {
51203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51208       };
51209     }
51210   }
51211 }
51212
51213
51214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51215   unsigned int jresult ;
51216   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51217   bool result;
51218
51219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51220   {
51221     try {
51222       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);
51223     } catch (std::out_of_range& e) {
51224       {
51225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51226       };
51227     } catch (std::exception& e) {
51228       {
51229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51230       };
51231     } catch (...) {
51232       {
51233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51234       };
51235     }
51236   }
51237   jresult = result;
51238   return jresult;
51239 }
51240
51241
51242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51243   unsigned long jresult ;
51244   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51245   std::size_t result;
51246
51247   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51248   {
51249     try {
51250       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);
51251     } catch (std::out_of_range& e) {
51252       {
51253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51254       };
51255     } catch (std::exception& e) {
51256       {
51257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51258       };
51259     } catch (...) {
51260       {
51261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51262       };
51263     }
51264   }
51265   jresult = (unsigned long)result;
51266   return jresult;
51267 }
51268
51269
51270 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51271   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51272   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51273
51274   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51275   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51276   {
51277     try {
51278       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293 }
51294
51295
51296 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51297   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51298   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51299
51300   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51301   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51302   {
51303     try {
51304       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51305     } catch (std::out_of_range& e) {
51306       {
51307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51308       };
51309     } catch (std::exception& e) {
51310       {
51311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (...) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51316       };
51317     }
51318   }
51319 }
51320
51321
51322 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51323   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51324   Dali::Actor arg2 ;
51325   Dali::LongPressGesture *arg3 = 0 ;
51326   Dali::Actor *argp2 ;
51327
51328   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51329   argp2 = (Dali::Actor *)jarg2;
51330   if (!argp2) {
51331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51332     return ;
51333   }
51334   arg2 = *argp2;
51335   arg3 = (Dali::LongPressGesture *)jarg3;
51336   if (!arg3) {
51337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51338     return ;
51339   }
51340   {
51341     try {
51342       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51343     } catch (std::out_of_range& e) {
51344       {
51345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51346       };
51347     } catch (std::exception& e) {
51348       {
51349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51350       };
51351     } catch (...) {
51352       {
51353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51354       };
51355     }
51356   }
51357 }
51358
51359
51360 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_LongPressGestureDetectedSignal() {
51361   void * jresult ;
51362   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51363
51364   {
51365     try {
51366       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51367     } catch (std::out_of_range& e) {
51368       {
51369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51370       };
51371     } catch (std::exception& e) {
51372       {
51373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51374       };
51375     } catch (...) {
51376       {
51377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51378       };
51379     }
51380   }
51381   jresult = (void *)result;
51382   return jresult;
51383 }
51384
51385
51386 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_LongPressGestureDetectedSignal(void * jarg1) {
51387   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51388
51389   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51390   {
51391     try {
51392       delete arg1;
51393     } catch (std::out_of_range& e) {
51394       {
51395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51396       };
51397     } catch (std::exception& e) {
51398       {
51399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (...) {
51402       {
51403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51404       };
51405     }
51406   }
51407 }
51408
51409
51410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Empty(void * jarg1) {
51411   unsigned int jresult ;
51412   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51413   bool result;
51414
51415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51416   {
51417     try {
51418       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);
51419     } catch (std::out_of_range& e) {
51420       {
51421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51422       };
51423     } catch (std::exception& e) {
51424       {
51425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51426       };
51427     } catch (...) {
51428       {
51429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51430       };
51431     }
51432   }
51433   jresult = result;
51434   return jresult;
51435 }
51436
51437
51438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51439   unsigned long jresult ;
51440   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51441   std::size_t result;
51442
51443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51444   {
51445     try {
51446       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);
51447     } catch (std::out_of_range& e) {
51448       {
51449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51450       };
51451     } catch (std::exception& e) {
51452       {
51453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51454       };
51455     } catch (...) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51458       };
51459     }
51460   }
51461   jresult = (unsigned long)result;
51462   return jresult;
51463 }
51464
51465
51466 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51467   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51468   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51469
51470   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51471   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51472   {
51473     try {
51474       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51475     } catch (std::out_of_range& e) {
51476       {
51477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51478       };
51479     } catch (std::exception& e) {
51480       {
51481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51482       };
51483     } catch (...) {
51484       {
51485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51486       };
51487     }
51488   }
51489 }
51490
51491
51492 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51493   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51494   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51495
51496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51497   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51498   {
51499     try {
51500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51501     } catch (std::out_of_range& e) {
51502       {
51503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51504       };
51505     } catch (std::exception& e) {
51506       {
51507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51508       };
51509     } catch (...) {
51510       {
51511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51512       };
51513     }
51514   }
51515 }
51516
51517
51518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51519   unsigned int jresult ;
51520   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51521   Dali::Actor arg2 ;
51522   Dali::TouchData *arg3 = 0 ;
51523   Dali::Actor *argp2 ;
51524   bool result;
51525
51526   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51527   argp2 = (Dali::Actor *)jarg2;
51528   if (!argp2) {
51529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51530     return 0;
51531   }
51532   arg2 = *argp2;
51533   arg3 = (Dali::TouchData *)jarg3;
51534   if (!arg3) {
51535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51536     return 0;
51537   }
51538   {
51539     try {
51540       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51541     } catch (std::out_of_range& e) {
51542       {
51543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51544       };
51545     } catch (std::exception& e) {
51546       {
51547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51548       };
51549     } catch (...) {
51550       {
51551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51552       };
51553     }
51554   }
51555   jresult = result;
51556   return jresult;
51557 }
51558
51559
51560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorTouchDataSignal() {
51561   void * jresult ;
51562   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51563
51564   {
51565     try {
51566       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51567     } catch (std::out_of_range& e) {
51568       {
51569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51570       };
51571     } catch (std::exception& e) {
51572       {
51573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (...) {
51576       {
51577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51578       };
51579     }
51580   }
51581   jresult = (void *)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorTouchDataSignal(void * jarg1) {
51587   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51588
51589   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51590   {
51591     try {
51592       delete arg1;
51593     } catch (std::out_of_range& e) {
51594       {
51595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51596       };
51597     } catch (std::exception& e) {
51598       {
51599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51600       };
51601     } catch (...) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51604       };
51605     }
51606   }
51607 }
51608
51609
51610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Empty(void * jarg1) {
51611   unsigned int jresult ;
51612   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51613   bool result;
51614
51615   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51616   {
51617     try {
51618       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);
51619     } catch (std::out_of_range& e) {
51620       {
51621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51622       };
51623     } catch (std::exception& e) {
51624       {
51625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51626       };
51627     } catch (...) {
51628       {
51629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51630       };
51631     }
51632   }
51633   jresult = result;
51634   return jresult;
51635 }
51636
51637
51638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_GetConnectionCount(void * jarg1) {
51639   unsigned long jresult ;
51640   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51641   std::size_t result;
51642
51643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51644   {
51645     try {
51646       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);
51647     } catch (std::out_of_range& e) {
51648       {
51649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51650       };
51651     } catch (std::exception& e) {
51652       {
51653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51654       };
51655     } catch (...) {
51656       {
51657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51658       };
51659     }
51660   }
51661   jresult = (unsigned long)result;
51662   return jresult;
51663 }
51664
51665
51666 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Connect(void * jarg1, void * jarg2) {
51667   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51668   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51669
51670   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51671   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51672   {
51673     try {
51674       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51675     } catch (std::out_of_range& e) {
51676       {
51677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51678       };
51679     } catch (std::exception& e) {
51680       {
51681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51682       };
51683     } catch (...) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51686       };
51687     }
51688   }
51689 }
51690
51691
51692 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Disconnect(void * jarg1, void * jarg2) {
51693   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51694   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51695
51696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51697   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51698   {
51699     try {
51700       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51701     } catch (std::out_of_range& e) {
51702       {
51703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51704       };
51705     } catch (std::exception& e) {
51706       {
51707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51708       };
51709     } catch (...) {
51710       {
51711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51712       };
51713     }
51714   }
51715 }
51716
51717
51718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorHoverEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51719   unsigned int jresult ;
51720   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51721   Dali::Actor arg2 ;
51722   Dali::HoverEvent *arg3 = 0 ;
51723   Dali::Actor *argp2 ;
51724   bool result;
51725
51726   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51727   argp2 = (Dali::Actor *)jarg2;
51728   if (!argp2) {
51729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51730     return 0;
51731   }
51732   arg2 = *argp2;
51733   arg3 = (Dali::HoverEvent *)jarg3;
51734   if (!arg3) {
51735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51736     return 0;
51737   }
51738   {
51739     try {
51740       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51741     } catch (std::out_of_range& e) {
51742       {
51743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51744       };
51745     } catch (std::exception& e) {
51746       {
51747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (...) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51752       };
51753     }
51754   }
51755   jresult = result;
51756   return jresult;
51757 }
51758
51759
51760 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorHoverEventSignal() {
51761   void * jresult ;
51762   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
51763
51764   {
51765     try {
51766       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
51767     } catch (std::out_of_range& e) {
51768       {
51769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51770       };
51771     } catch (std::exception& e) {
51772       {
51773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51774       };
51775     } catch (...) {
51776       {
51777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51778       };
51779     }
51780   }
51781   jresult = (void *)result;
51782   return jresult;
51783 }
51784
51785
51786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorHoverEventSignal(void * jarg1) {
51787   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51788
51789   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51790   {
51791     try {
51792       delete arg1;
51793     } catch (std::out_of_range& e) {
51794       {
51795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51796       };
51797     } catch (std::exception& e) {
51798       {
51799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51800       };
51801     } catch (...) {
51802       {
51803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51804       };
51805     }
51806   }
51807 }
51808
51809
51810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Empty(void * jarg1) {
51811   unsigned int jresult ;
51812   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51813   bool result;
51814
51815   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51816   {
51817     try {
51818       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);
51819     } catch (std::out_of_range& e) {
51820       {
51821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51822       };
51823     } catch (std::exception& e) {
51824       {
51825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51826       };
51827     } catch (...) {
51828       {
51829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51830       };
51831     }
51832   }
51833   jresult = result;
51834   return jresult;
51835 }
51836
51837
51838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_GetConnectionCount(void * jarg1) {
51839   unsigned long jresult ;
51840   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51841   std::size_t result;
51842
51843   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51844   {
51845     try {
51846       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);
51847     } catch (std::out_of_range& e) {
51848       {
51849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51850       };
51851     } catch (std::exception& e) {
51852       {
51853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51858       };
51859     }
51860   }
51861   jresult = (unsigned long)result;
51862   return jresult;
51863 }
51864
51865
51866 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Connect(void * jarg1, void * jarg2) {
51867   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51868   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51869
51870   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51871   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51872   {
51873     try {
51874       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51882       };
51883     } catch (...) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51886       };
51887     }
51888   }
51889 }
51890
51891
51892 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
51893   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51894   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51895
51896   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51897   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51898   {
51899     try {
51900       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51901     } catch (std::out_of_range& e) {
51902       {
51903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51904       };
51905     } catch (std::exception& e) {
51906       {
51907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51908       };
51909     } catch (...) {
51910       {
51911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51912       };
51913     }
51914   }
51915 }
51916
51917
51918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorWheelEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51919   unsigned int jresult ;
51920   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51921   Dali::Actor arg2 ;
51922   Dali::WheelEvent *arg3 = 0 ;
51923   Dali::Actor *argp2 ;
51924   bool result;
51925
51926   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51927   argp2 = (Dali::Actor *)jarg2;
51928   if (!argp2) {
51929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51930     return 0;
51931   }
51932   arg2 = *argp2;
51933   arg3 = (Dali::WheelEvent *)jarg3;
51934   if (!arg3) {
51935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51936     return 0;
51937   }
51938   {
51939     try {
51940       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
51941     } catch (std::out_of_range& e) {
51942       {
51943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (std::exception& e) {
51946       {
51947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51948       };
51949     } catch (...) {
51950       {
51951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51952       };
51953     }
51954   }
51955   jresult = result;
51956   return jresult;
51957 }
51958
51959
51960 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorWheelEventSignal() {
51961   void * jresult ;
51962   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
51963
51964   {
51965     try {
51966       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
51967     } catch (std::out_of_range& e) {
51968       {
51969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51970       };
51971     } catch (std::exception& e) {
51972       {
51973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51974       };
51975     } catch (...) {
51976       {
51977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51978       };
51979     }
51980   }
51981   jresult = (void *)result;
51982   return jresult;
51983 }
51984
51985
51986 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorWheelEventSignal(void * jarg1) {
51987   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51988
51989   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51990   {
51991     try {
51992       delete arg1;
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007 }
52008
52009
52010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ActorSignal_Empty(void * jarg1) {
52011   unsigned int jresult ;
52012   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52013   bool result;
52014
52015   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52016   {
52017     try {
52018       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52030       };
52031     }
52032   }
52033   jresult = result;
52034   return jresult;
52035 }
52036
52037
52038 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorSignal_GetConnectionCount(void * jarg1) {
52039   unsigned long jresult ;
52040   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52041   std::size_t result;
52042
52043   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52044   {
52045     try {
52046       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52047     } catch (std::out_of_range& e) {
52048       {
52049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52050       };
52051     } catch (std::exception& e) {
52052       {
52053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52054       };
52055     } catch (...) {
52056       {
52057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52058       };
52059     }
52060   }
52061   jresult = (unsigned long)result;
52062   return jresult;
52063 }
52064
52065
52066 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Connect(void * jarg1, void * jarg2) {
52067   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52068   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52069
52070   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52071   arg2 = (void (*)(Dali::Actor))jarg2;
52072   {
52073     try {
52074       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52075     } catch (std::out_of_range& e) {
52076       {
52077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52078       };
52079     } catch (std::exception& e) {
52080       {
52081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52082       };
52083     } catch (...) {
52084       {
52085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52086       };
52087     }
52088   }
52089 }
52090
52091
52092 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52093   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52094   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52095
52096   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52097   arg2 = (void (*)(Dali::Actor))jarg2;
52098   {
52099     try {
52100       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52101     } catch (std::out_of_range& e) {
52102       {
52103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52104       };
52105     } catch (std::exception& e) {
52106       {
52107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52108       };
52109     } catch (...) {
52110       {
52111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52112       };
52113     }
52114   }
52115 }
52116
52117
52118 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorSignal_Emit(void * jarg1, void * jarg2) {
52119   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52120   Dali::Actor arg2 ;
52121   Dali::Actor *argp2 ;
52122
52123   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52124   argp2 = (Dali::Actor *)jarg2;
52125   if (!argp2) {
52126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52127     return ;
52128   }
52129   arg2 = *argp2;
52130   {
52131     try {
52132       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52133     } catch (std::out_of_range& e) {
52134       {
52135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52136       };
52137     } catch (std::exception& e) {
52138       {
52139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52140       };
52141     } catch (...) {
52142       {
52143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52144       };
52145     }
52146   }
52147 }
52148
52149
52150 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorSignal() {
52151   void * jresult ;
52152   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52153
52154   {
52155     try {
52156       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52157     } catch (std::out_of_range& e) {
52158       {
52159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52160       };
52161     } catch (std::exception& e) {
52162       {
52163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52164       };
52165     } catch (...) {
52166       {
52167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52168       };
52169     }
52170   }
52171   jresult = (void *)result;
52172   return jresult;
52173 }
52174
52175
52176 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorSignal(void * jarg1) {
52177   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52178
52179   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52180   {
52181     try {
52182       delete arg1;
52183     } catch (std::out_of_range& e) {
52184       {
52185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52186       };
52187     } catch (std::exception& e) {
52188       {
52189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52190       };
52191     } catch (...) {
52192       {
52193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52194       };
52195     }
52196   }
52197 }
52198
52199
52200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyEventSignal_Empty(void * jarg1) {
52201   unsigned int jresult ;
52202   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52203   bool result;
52204
52205   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52206   {
52207     try {
52208       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52209     } catch (std::out_of_range& e) {
52210       {
52211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52212       };
52213     } catch (std::exception& e) {
52214       {
52215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52216       };
52217     } catch (...) {
52218       {
52219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52220       };
52221     }
52222   }
52223   jresult = result;
52224   return jresult;
52225 }
52226
52227
52228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyEventSignal_GetConnectionCount(void * jarg1) {
52229   unsigned long jresult ;
52230   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52231   std::size_t result;
52232
52233   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52234   {
52235     try {
52236       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52237     } catch (std::out_of_range& e) {
52238       {
52239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52240       };
52241     } catch (std::exception& e) {
52242       {
52243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52244       };
52245     } catch (...) {
52246       {
52247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52248       };
52249     }
52250   }
52251   jresult = (unsigned long)result;
52252   return jresult;
52253 }
52254
52255
52256 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52257   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52258   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52259
52260   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52261   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52262   {
52263     try {
52264       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52265     } catch (std::out_of_range& e) {
52266       {
52267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52268       };
52269     } catch (std::exception& e) {
52270       {
52271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52272       };
52273     } catch (...) {
52274       {
52275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52276       };
52277     }
52278   }
52279 }
52280
52281
52282 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52283   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52284   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52285
52286   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52287   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52288   {
52289     try {
52290       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52291     } catch (std::out_of_range& e) {
52292       {
52293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52294       };
52295     } catch (std::exception& e) {
52296       {
52297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52298       };
52299     } catch (...) {
52300       {
52301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52302       };
52303     }
52304   }
52305 }
52306
52307
52308 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52309   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52310   Dali::KeyEvent *arg2 = 0 ;
52311
52312   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52313   arg2 = (Dali::KeyEvent *)jarg2;
52314   if (!arg2) {
52315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52316     return ;
52317   }
52318   {
52319     try {
52320       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52321     } catch (std::out_of_range& e) {
52322       {
52323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52324       };
52325     } catch (std::exception& e) {
52326       {
52327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52328       };
52329     } catch (...) {
52330       {
52331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52332       };
52333     }
52334   }
52335 }
52336
52337
52338 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyEventSignal() {
52339   void * jresult ;
52340   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52341
52342   {
52343     try {
52344       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52345     } catch (std::out_of_range& e) {
52346       {
52347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52348       };
52349     } catch (std::exception& e) {
52350       {
52351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52352       };
52353     } catch (...) {
52354       {
52355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52356       };
52357     }
52358   }
52359   jresult = (void *)result;
52360   return jresult;
52361 }
52362
52363
52364 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyEventSignal(void * jarg1) {
52365   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52366
52367   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52368   {
52369     try {
52370       delete arg1;
52371     } catch (std::out_of_range& e) {
52372       {
52373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52374       };
52375     } catch (std::exception& e) {
52376       {
52377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52378       };
52379     } catch (...) {
52380       {
52381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52382       };
52383     }
52384   }
52385 }
52386
52387
52388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TouchSignal_Empty(void * jarg1) {
52389   unsigned int jresult ;
52390   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52391   bool result;
52392
52393   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52394   {
52395     try {
52396       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52397     } catch (std::out_of_range& e) {
52398       {
52399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (std::exception& e) {
52402       {
52403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52408       };
52409     }
52410   }
52411   jresult = result;
52412   return jresult;
52413 }
52414
52415
52416 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TouchSignal_GetConnectionCount(void * jarg1) {
52417   unsigned long jresult ;
52418   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52419   std::size_t result;
52420
52421   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52422   {
52423     try {
52424       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52425     } catch (std::out_of_range& e) {
52426       {
52427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52428       };
52429     } catch (std::exception& e) {
52430       {
52431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52432       };
52433     } catch (...) {
52434       {
52435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52436       };
52437     }
52438   }
52439   jresult = (unsigned long)result;
52440   return jresult;
52441 }
52442
52443
52444 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Connect(void * jarg1, void * jarg2) {
52445   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52446   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52447
52448   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52449   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52450   {
52451     try {
52452       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52453     } catch (std::out_of_range& e) {
52454       {
52455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52456       };
52457     } catch (std::exception& e) {
52458       {
52459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52460       };
52461     } catch (...) {
52462       {
52463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52464       };
52465     }
52466   }
52467 }
52468
52469
52470 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52471   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52472   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52473
52474   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52475   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52476   {
52477     try {
52478       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52479     } catch (std::out_of_range& e) {
52480       {
52481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52482       };
52483     } catch (std::exception& e) {
52484       {
52485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52486       };
52487     } catch (...) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52490       };
52491     }
52492   }
52493 }
52494
52495
52496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TouchSignal_Emit(void * jarg1, void * jarg2) {
52497   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52498   Dali::TouchData *arg2 = 0 ;
52499
52500   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52501   arg2 = (Dali::TouchData *)jarg2;
52502   if (!arg2) {
52503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52504     return ;
52505   }
52506   {
52507     try {
52508       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52509     } catch (std::out_of_range& e) {
52510       {
52511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52512       };
52513     } catch (std::exception& e) {
52514       {
52515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52516       };
52517     } catch (...) {
52518       {
52519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52520       };
52521     }
52522   }
52523 }
52524
52525
52526 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TouchSignal() {
52527   void * jresult ;
52528   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52529
52530   {
52531     try {
52532       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52533     } catch (std::out_of_range& e) {
52534       {
52535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52536       };
52537     } catch (std::exception& e) {
52538       {
52539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (...) {
52542       {
52543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52544       };
52545     }
52546   }
52547   jresult = (void *)result;
52548   return jresult;
52549 }
52550
52551
52552 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TouchSignal(void * jarg1) {
52553   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52554
52555   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52556   {
52557     try {
52558       delete arg1;
52559     } catch (std::out_of_range& e) {
52560       {
52561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52562       };
52563     } catch (std::exception& e) {
52564       {
52565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52570       };
52571     }
52572   }
52573 }
52574
52575
52576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Empty(void * jarg1) {
52577   unsigned int jresult ;
52578   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52579   bool result;
52580
52581   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52582   {
52583     try {
52584       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52585     } catch (std::out_of_range& e) {
52586       {
52587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52588       };
52589     } catch (std::exception& e) {
52590       {
52591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52592       };
52593     } catch (...) {
52594       {
52595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52596       };
52597     }
52598   }
52599   jresult = result;
52600   return jresult;
52601 }
52602
52603
52604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_GetConnectionCount(void * jarg1) {
52605   unsigned long jresult ;
52606   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52607   std::size_t result;
52608
52609   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52610   {
52611     try {
52612       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52613     } catch (std::out_of_range& e) {
52614       {
52615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52616       };
52617     } catch (std::exception& e) {
52618       {
52619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52620       };
52621     } catch (...) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52624       };
52625     }
52626   }
52627   jresult = (unsigned long)result;
52628   return jresult;
52629 }
52630
52631
52632 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Connect(void * jarg1, void * jarg2) {
52633   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52634   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52635
52636   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52637   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52638   {
52639     try {
52640       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52641     } catch (std::out_of_range& e) {
52642       {
52643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52644       };
52645     } catch (std::exception& e) {
52646       {
52647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (...) {
52650       {
52651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52652       };
52653     }
52654   }
52655 }
52656
52657
52658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Disconnect(void * jarg1, void * jarg2) {
52659   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52660   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52661
52662   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52663   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52664   {
52665     try {
52666       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (...) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52678       };
52679     }
52680   }
52681 }
52682
52683
52684 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StageWheelEventSignal_Emit(void * jarg1, void * jarg2) {
52685   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52686   Dali::WheelEvent *arg2 = 0 ;
52687
52688   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52689   arg2 = (Dali::WheelEvent *)jarg2;
52690   if (!arg2) {
52691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52692     return ;
52693   }
52694   {
52695     try {
52696       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
52697     } catch (std::out_of_range& e) {
52698       {
52699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52700       };
52701     } catch (std::exception& e) {
52702       {
52703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52704       };
52705     } catch (...) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52708       };
52709     }
52710   }
52711 }
52712
52713
52714 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StageWheelEventSignal() {
52715   void * jresult ;
52716   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
52717
52718   {
52719     try {
52720       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
52721     } catch (std::out_of_range& e) {
52722       {
52723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52724       };
52725     } catch (std::exception& e) {
52726       {
52727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (...) {
52730       {
52731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52732       };
52733     }
52734   }
52735   jresult = (void *)result;
52736   return jresult;
52737 }
52738
52739
52740 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StageWheelEventSignal(void * jarg1) {
52741   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52742
52743   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52744   {
52745     try {
52746       delete arg1;
52747     } catch (std::out_of_range& e) {
52748       {
52749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52750       };
52751     } catch (std::exception& e) {
52752       {
52753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52754       };
52755     } catch (...) {
52756       {
52757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52758       };
52759     }
52760   }
52761 }
52762
52763
52764 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_0() {
52765   void * jresult ;
52766   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52767
52768   {
52769     try {
52770       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
52771     } catch (std::out_of_range& e) {
52772       {
52773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52774       };
52775     } catch (std::exception& e) {
52776       {
52777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52778       };
52779     } catch (...) {
52780       {
52781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52782       };
52783     }
52784   }
52785   jresult = (void *)result;
52786   return jresult;
52787 }
52788
52789
52790 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
52791   void * jresult ;
52792   Dali::Radian arg1 ;
52793   Dali::Radian arg2 ;
52794   Dali::Radian *argp1 ;
52795   Dali::Radian *argp2 ;
52796   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52797
52798   argp1 = (Dali::Radian *)jarg1;
52799   if (!argp1) {
52800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52801     return 0;
52802   }
52803   arg1 = *argp1;
52804   argp2 = (Dali::Radian *)jarg2;
52805   if (!argp2) {
52806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52807     return 0;
52808   }
52809   arg2 = *argp2;
52810   {
52811     try {
52812       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
52813     } catch (std::out_of_range& e) {
52814       {
52815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (std::exception& e) {
52818       {
52819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (...) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52824       };
52825     }
52826   }
52827   jresult = (void *)result;
52828   return jresult;
52829 }
52830
52831
52832 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AngleThresholdPair__SWIG_2(void * jarg1) {
52833   void * jresult ;
52834   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
52835   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52836
52837   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52838   if (!arg1) {
52839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
52840     return 0;
52841   }
52842   {
52843     try {
52844       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
52845     } catch (std::out_of_range& e) {
52846       {
52847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52848       };
52849     } catch (std::exception& e) {
52850       {
52851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52852       };
52853     } catch (...) {
52854       {
52855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52856       };
52857     }
52858   }
52859   jresult = (void *)result;
52860   return jresult;
52861 }
52862
52863
52864 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
52865   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52866   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52867
52868   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52869   arg2 = (Dali::Radian *)jarg2;
52870   if (arg1) (arg1)->first = *arg2;
52871 }
52872
52873
52874 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleThresholdPair_first_get(void * jarg1) {
52875   void * jresult ;
52876   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52877   Dali::Radian *result = 0 ;
52878
52879   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52880   result = (Dali::Radian *)& ((arg1)->first);
52881   jresult = (void *)result;
52882   return jresult;
52883 }
52884
52885
52886 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
52887   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52888   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52889
52890   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52891   arg2 = (Dali::Radian *)jarg2;
52892   if (arg1) (arg1)->second = *arg2;
52893 }
52894
52895
52896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AngleThresholdPair_second_get(void * jarg1) {
52897   void * jresult ;
52898   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52899   Dali::Radian *result = 0 ;
52900
52901   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52902   result = (Dali::Radian *)& ((arg1)->second);
52903   jresult = (void *)result;
52904   return jresult;
52905 }
52906
52907
52908 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AngleThresholdPair(void * jarg1) {
52909   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52910
52911   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52912   {
52913     try {
52914       delete arg1;
52915     } catch (std::out_of_range& e) {
52916       {
52917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52918       };
52919     } catch (std::exception& e) {
52920       {
52921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52922       };
52923     } catch (...) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52926       };
52927     }
52928   }
52929 }
52930
52931
52932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Empty(void * jarg1) {
52933   unsigned int jresult ;
52934   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52935   bool result;
52936
52937   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52938   {
52939     try {
52940       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);
52941     } catch (std::out_of_range& e) {
52942       {
52943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52944       };
52945     } catch (std::exception& e) {
52946       {
52947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52948       };
52949     } catch (...) {
52950       {
52951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52952       };
52953     }
52954   }
52955   jresult = result;
52956   return jresult;
52957 }
52958
52959
52960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52961   unsigned long jresult ;
52962   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52963   std::size_t result;
52964
52965   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52966   {
52967     try {
52968       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);
52969     } catch (std::out_of_range& e) {
52970       {
52971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52972       };
52973     } catch (std::exception& e) {
52974       {
52975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52976       };
52977     } catch (...) {
52978       {
52979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52980       };
52981     }
52982   }
52983   jresult = (unsigned long)result;
52984   return jresult;
52985 }
52986
52987
52988 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52989   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52990   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
52991
52992   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52993   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
52994   {
52995     try {
52996       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52997     } catch (std::out_of_range& e) {
52998       {
52999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53000       };
53001     } catch (std::exception& e) {
53002       {
53003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53004       };
53005     } catch (...) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53008       };
53009     }
53010   }
53011 }
53012
53013
53014 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53015   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53016   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53017
53018   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53019   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53020   {
53021     try {
53022       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53023     } catch (std::out_of_range& e) {
53024       {
53025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53026       };
53027     } catch (std::exception& e) {
53028       {
53029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53030       };
53031     } catch (...) {
53032       {
53033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53034       };
53035     }
53036   }
53037 }
53038
53039
53040 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53041   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53042   Dali::Actor arg2 ;
53043   Dali::PanGesture *arg3 = 0 ;
53044   Dali::Actor *argp2 ;
53045
53046   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53047   argp2 = (Dali::Actor *)jarg2;
53048   if (!argp2) {
53049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53050     return ;
53051   }
53052   arg2 = *argp2;
53053   arg3 = (Dali::PanGesture *)jarg3;
53054   if (!arg3) {
53055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53056     return ;
53057   }
53058   {
53059     try {
53060       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53061     } catch (std::out_of_range& e) {
53062       {
53063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53064       };
53065     } catch (std::exception& e) {
53066       {
53067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53068       };
53069     } catch (...) {
53070       {
53071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53072       };
53073     }
53074   }
53075 }
53076
53077
53078 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PanGestureDetectedSignal() {
53079   void * jresult ;
53080   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53081
53082   {
53083     try {
53084       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53085     } catch (std::out_of_range& e) {
53086       {
53087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53088       };
53089     } catch (std::exception& e) {
53090       {
53091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53092       };
53093     } catch (...) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53096       };
53097     }
53098   }
53099   jresult = (void *)result;
53100   return jresult;
53101 }
53102
53103
53104 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PanGestureDetectedSignal(void * jarg1) {
53105   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53106
53107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53108   {
53109     try {
53110       delete arg1;
53111     } catch (std::out_of_range& e) {
53112       {
53113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53114       };
53115     } catch (std::exception& e) {
53116       {
53117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53118       };
53119     } catch (...) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53122       };
53123     }
53124   }
53125 }
53126
53127
53128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Empty(void * jarg1) {
53129   unsigned int jresult ;
53130   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53131   bool result;
53132
53133   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53134   {
53135     try {
53136       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);
53137     } catch (std::out_of_range& e) {
53138       {
53139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53140       };
53141     } catch (std::exception& e) {
53142       {
53143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53144       };
53145     } catch (...) {
53146       {
53147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53148       };
53149     }
53150   }
53151   jresult = result;
53152   return jresult;
53153 }
53154
53155
53156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53157   unsigned long jresult ;
53158   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53159   std::size_t result;
53160
53161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53162   {
53163     try {
53164       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);
53165     } catch (std::out_of_range& e) {
53166       {
53167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53168       };
53169     } catch (std::exception& e) {
53170       {
53171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53172       };
53173     } catch (...) {
53174       {
53175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53176       };
53177     }
53178   }
53179   jresult = (unsigned long)result;
53180   return jresult;
53181 }
53182
53183
53184 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53185   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53186   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53187
53188   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53189   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53190   {
53191     try {
53192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53193     } catch (std::out_of_range& e) {
53194       {
53195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53196       };
53197     } catch (std::exception& e) {
53198       {
53199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53200       };
53201     } catch (...) {
53202       {
53203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53204       };
53205     }
53206   }
53207 }
53208
53209
53210 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53211   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53212   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53213
53214   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53215   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53216   {
53217     try {
53218       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53219     } catch (std::out_of_range& e) {
53220       {
53221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53222       };
53223     } catch (std::exception& e) {
53224       {
53225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53226       };
53227     } catch (...) {
53228       {
53229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53230       };
53231     }
53232   }
53233 }
53234
53235
53236 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53237   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53238   Dali::Actor arg2 ;
53239   Dali::PinchGesture *arg3 = 0 ;
53240   Dali::Actor *argp2 ;
53241
53242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53243   argp2 = (Dali::Actor *)jarg2;
53244   if (!argp2) {
53245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53246     return ;
53247   }
53248   arg2 = *argp2;
53249   arg3 = (Dali::PinchGesture *)jarg3;
53250   if (!arg3) {
53251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53252     return ;
53253   }
53254   {
53255     try {
53256       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53257     } catch (std::out_of_range& e) {
53258       {
53259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53260       };
53261     } catch (std::exception& e) {
53262       {
53263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (...) {
53266       {
53267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53268       };
53269     }
53270   }
53271 }
53272
53273
53274 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PinchGestureDetectedSignal() {
53275   void * jresult ;
53276   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53277
53278   {
53279     try {
53280       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53281     } catch (std::out_of_range& e) {
53282       {
53283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53284       };
53285     } catch (std::exception& e) {
53286       {
53287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53288       };
53289     } catch (...) {
53290       {
53291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53292       };
53293     }
53294   }
53295   jresult = (void *)result;
53296   return jresult;
53297 }
53298
53299
53300 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PinchGestureDetectedSignal(void * jarg1) {
53301   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53302
53303   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53304   {
53305     try {
53306       delete arg1;
53307     } catch (std::out_of_range& e) {
53308       {
53309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53310       };
53311     } catch (std::exception& e) {
53312       {
53313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53314       };
53315     } catch (...) {
53316       {
53317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53318       };
53319     }
53320   }
53321 }
53322
53323
53324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Empty(void * jarg1) {
53325   unsigned int jresult ;
53326   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53327   bool result;
53328
53329   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53330   {
53331     try {
53332       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);
53333     } catch (std::out_of_range& e) {
53334       {
53335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53336       };
53337     } catch (std::exception& e) {
53338       {
53339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53340       };
53341     } catch (...) {
53342       {
53343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53344       };
53345     }
53346   }
53347   jresult = result;
53348   return jresult;
53349 }
53350
53351
53352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53353   unsigned long jresult ;
53354   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53355   std::size_t result;
53356
53357   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53358   {
53359     try {
53360       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);
53361     } catch (std::out_of_range& e) {
53362       {
53363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53364       };
53365     } catch (std::exception& e) {
53366       {
53367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53368       };
53369     } catch (...) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53372       };
53373     }
53374   }
53375   jresult = (unsigned long)result;
53376   return jresult;
53377 }
53378
53379
53380 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53381   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53382   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53383
53384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53385   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53386   {
53387     try {
53388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53389     } catch (std::out_of_range& e) {
53390       {
53391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (std::exception& e) {
53394       {
53395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403 }
53404
53405
53406 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53407   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53408   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53409
53410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53411   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53412   {
53413     try {
53414       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53415     } catch (std::out_of_range& e) {
53416       {
53417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53418       };
53419     } catch (std::exception& e) {
53420       {
53421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53422       };
53423     } catch (...) {
53424       {
53425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53426       };
53427     }
53428   }
53429 }
53430
53431
53432 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53433   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53434   Dali::Actor arg2 ;
53435   Dali::TapGesture *arg3 = 0 ;
53436   Dali::Actor *argp2 ;
53437
53438   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53439   argp2 = (Dali::Actor *)jarg2;
53440   if (!argp2) {
53441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53442     return ;
53443   }
53444   arg2 = *argp2;
53445   arg3 = (Dali::TapGesture *)jarg3;
53446   if (!arg3) {
53447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53448     return ;
53449   }
53450   {
53451     try {
53452       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
53453     } catch (std::out_of_range& e) {
53454       {
53455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53456       };
53457     } catch (std::exception& e) {
53458       {
53459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53460       };
53461     } catch (...) {
53462       {
53463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53464       };
53465     }
53466   }
53467 }
53468
53469
53470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TapGestureDetectedSignal() {
53471   void * jresult ;
53472   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
53473
53474   {
53475     try {
53476       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
53477     } catch (std::out_of_range& e) {
53478       {
53479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53480       };
53481     } catch (std::exception& e) {
53482       {
53483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53484       };
53485     } catch (...) {
53486       {
53487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53488       };
53489     }
53490   }
53491   jresult = (void *)result;
53492   return jresult;
53493 }
53494
53495
53496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TapGestureDetectedSignal(void * jarg1) {
53497   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53498
53499   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53500   {
53501     try {
53502       delete arg1;
53503     } catch (std::out_of_range& e) {
53504       {
53505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53506       };
53507     } catch (std::exception& e) {
53508       {
53509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (...) {
53512       {
53513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53514       };
53515     }
53516   }
53517 }
53518
53519
53520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AnimationSignal_Empty(void * jarg1) {
53521   unsigned int jresult ;
53522   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53523   bool result;
53524
53525   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53526   {
53527     try {
53528       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53529     } catch (std::out_of_range& e) {
53530       {
53531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53532       };
53533     } catch (std::exception& e) {
53534       {
53535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53536       };
53537     } catch (...) {
53538       {
53539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53540       };
53541     }
53542   }
53543   jresult = result;
53544   return jresult;
53545 }
53546
53547
53548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AnimationSignal_GetConnectionCount(void * jarg1) {
53549   unsigned long jresult ;
53550   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53551   std::size_t result;
53552
53553   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53554   {
53555     try {
53556       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53568       };
53569     }
53570   }
53571   jresult = (unsigned long)result;
53572   return jresult;
53573 }
53574
53575
53576 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Connect(void * jarg1, void * jarg2) {
53577   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53578   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53579
53580   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53581   arg2 = (void (*)(Dali::Animation &))jarg2;
53582   {
53583     try {
53584       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
53585     } catch (std::out_of_range& e) {
53586       {
53587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53588       };
53589     } catch (std::exception& e) {
53590       {
53591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53592       };
53593     } catch (...) {
53594       {
53595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53596       };
53597     }
53598   }
53599 }
53600
53601
53602 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
53603   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53604   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53605
53606   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53607   arg2 = (void (*)(Dali::Animation &))jarg2;
53608   {
53609     try {
53610       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
53611     } catch (std::out_of_range& e) {
53612       {
53613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53614       };
53615     } catch (std::exception& e) {
53616       {
53617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (...) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53622       };
53623     }
53624   }
53625 }
53626
53627
53628 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AnimationSignal_Emit(void * jarg1, void * jarg2) {
53629   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53630   Dali::Animation *arg2 = 0 ;
53631
53632   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53633   arg2 = (Dali::Animation *)jarg2;
53634   if (!arg2) {
53635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
53636     return ;
53637   }
53638   {
53639     try {
53640       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
53641     } catch (std::out_of_range& e) {
53642       {
53643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53644       };
53645     } catch (std::exception& e) {
53646       {
53647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53648       };
53649     } catch (...) {
53650       {
53651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53652       };
53653     }
53654   }
53655 }
53656
53657
53658 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AnimationSignal() {
53659   void * jresult ;
53660   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
53661
53662   {
53663     try {
53664       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
53665     } catch (std::out_of_range& e) {
53666       {
53667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53668       };
53669     } catch (std::exception& e) {
53670       {
53671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53672       };
53673     } catch (...) {
53674       {
53675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53676       };
53677     }
53678   }
53679   jresult = (void *)result;
53680   return jresult;
53681 }
53682
53683
53684 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AnimationSignal(void * jarg1) {
53685   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53686
53687   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53688   {
53689     try {
53690       delete arg1;
53691     } catch (std::out_of_range& e) {
53692       {
53693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53694       };
53695     } catch (std::exception& e) {
53696       {
53697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53698       };
53699     } catch (...) {
53700       {
53701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53702       };
53703     }
53704   }
53705 }
53706
53707
53708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Empty(void * jarg1) {
53709   unsigned int jresult ;
53710   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53711   bool result;
53712
53713   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53714   {
53715     try {
53716       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53717     } catch (std::out_of_range& e) {
53718       {
53719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53720       };
53721     } catch (std::exception& e) {
53722       {
53723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53724       };
53725     } catch (...) {
53726       {
53727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53728       };
53729     }
53730   }
53731   jresult = result;
53732   return jresult;
53733 }
53734
53735
53736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ResourceImageSignal_GetConnectionCount(void * jarg1) {
53737   unsigned long jresult ;
53738   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53739   std::size_t result;
53740
53741   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53742   {
53743     try {
53744       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53745     } catch (std::out_of_range& e) {
53746       {
53747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53748       };
53749     } catch (std::exception& e) {
53750       {
53751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53752       };
53753     } catch (...) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53756       };
53757     }
53758   }
53759   jresult = (unsigned long)result;
53760   return jresult;
53761 }
53762
53763
53764 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
53765   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53766   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53767
53768   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53769   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53770   {
53771     try {
53772       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
53773     } catch (std::out_of_range& e) {
53774       {
53775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53776       };
53777     } catch (std::exception& e) {
53778       {
53779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53780       };
53781     } catch (...) {
53782       {
53783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53784       };
53785     }
53786   }
53787 }
53788
53789
53790 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
53791   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53792   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53793
53794   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53795   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53796   {
53797     try {
53798       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
53799     } catch (std::out_of_range& e) {
53800       {
53801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53802       };
53803     } catch (std::exception& e) {
53804       {
53805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53806       };
53807     } catch (...) {
53808       {
53809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53810       };
53811     }
53812   }
53813 }
53814
53815
53816 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
53817   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53818   Dali::ResourceImage arg2 ;
53819   Dali::ResourceImage *argp2 ;
53820
53821   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53822   argp2 = (Dali::ResourceImage *)jarg2;
53823   if (!argp2) {
53824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
53825     return ;
53826   }
53827   arg2 = *argp2;
53828   {
53829     try {
53830       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
53831     } catch (std::out_of_range& e) {
53832       {
53833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53834       };
53835     } catch (std::exception& e) {
53836       {
53837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53838       };
53839     } catch (...) {
53840       {
53841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53842       };
53843     }
53844   }
53845 }
53846
53847
53848 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ResourceImageSignal() {
53849   void * jresult ;
53850   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
53851
53852   {
53853     try {
53854       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
53855     } catch (std::out_of_range& e) {
53856       {
53857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (std::exception& e) {
53860       {
53861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53862       };
53863     } catch (...) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53866       };
53867     }
53868   }
53869   jresult = (void *)result;
53870   return jresult;
53871 }
53872
53873
53874 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ResourceImageSignal(void * jarg1) {
53875   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53876
53877   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53878   {
53879     try {
53880       delete arg1;
53881     } catch (std::out_of_range& e) {
53882       {
53883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53884       };
53885     } catch (std::exception& e) {
53886       {
53887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53892       };
53893     }
53894   }
53895 }
53896
53897
53898 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Timer__SWIG_0() {
53899   void * jresult ;
53900   Dali::Timer *result = 0 ;
53901
53902   {
53903     try {
53904       result = (Dali::Timer *)new Dali::Timer();
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53912       };
53913     } catch (...) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53916       };
53917     }
53918   }
53919   jresult = (void *)result;
53920   return jresult;
53921 }
53922
53923
53924 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_New(unsigned int jarg1) {
53925   void * jresult ;
53926   unsigned int arg1 ;
53927   Dali::Timer result;
53928
53929   arg1 = (unsigned int)jarg1;
53930   {
53931     try {
53932       result = Dali::Timer::New(arg1);
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53944       };
53945     }
53946   }
53947   jresult = new Dali::Timer((const Dali::Timer &)result);
53948   return jresult;
53949 }
53950
53951
53952 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Timer__SWIG_1(void * jarg1) {
53953   void * jresult ;
53954   Dali::Timer *arg1 = 0 ;
53955   Dali::Timer *result = 0 ;
53956
53957   arg1 = (Dali::Timer *)jarg1;
53958   if (!arg1) {
53959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
53960     return 0;
53961   }
53962   {
53963     try {
53964       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
53965     } catch (std::out_of_range& e) {
53966       {
53967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (std::exception& e) {
53970       {
53971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979   jresult = (void *)result;
53980   return jresult;
53981 }
53982
53983
53984 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_Assign(void * jarg1, void * jarg2) {
53985   void * jresult ;
53986   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53987   Dali::Timer *arg2 = 0 ;
53988   Dali::Timer *result = 0 ;
53989
53990   arg1 = (Dali::Timer *)jarg1;
53991   arg2 = (Dali::Timer *)jarg2;
53992   if (!arg2) {
53993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
53994     return 0;
53995   }
53996   {
53997     try {
53998       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
53999     } catch (std::out_of_range& e) {
54000       {
54001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54002       };
54003     } catch (std::exception& e) {
54004       {
54005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54006       };
54007     } catch (...) {
54008       {
54009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54010       };
54011     }
54012   }
54013   jresult = (void *)result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Timer(void * jarg1) {
54019   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54020
54021   arg1 = (Dali::Timer *)jarg1;
54022   {
54023     try {
54024       delete arg1;
54025     } catch (std::out_of_range& e) {
54026       {
54027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (std::exception& e) {
54030       {
54031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54032       };
54033     } catch (...) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54036       };
54037     }
54038   }
54039 }
54040
54041
54042 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_DownCast(void * jarg1) {
54043   void * jresult ;
54044   Dali::BaseHandle arg1 ;
54045   Dali::BaseHandle *argp1 ;
54046   Dali::Timer result;
54047
54048   argp1 = (Dali::BaseHandle *)jarg1;
54049   if (!argp1) {
54050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54051     return 0;
54052   }
54053   arg1 = *argp1;
54054   {
54055     try {
54056       result = Dali::Timer::DownCast(arg1);
54057     } catch (std::out_of_range& e) {
54058       {
54059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54060       };
54061     } catch (std::exception& e) {
54062       {
54063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54068       };
54069     }
54070   }
54071   jresult = new Dali::Timer((const Dali::Timer &)result);
54072   return jresult;
54073 }
54074
54075
54076 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_Start(void * jarg1) {
54077   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54078
54079   arg1 = (Dali::Timer *)jarg1;
54080   {
54081     try {
54082       (arg1)->Start();
54083     } catch (std::out_of_range& e) {
54084       {
54085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (std::exception& e) {
54088       {
54089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54090       };
54091     } catch (...) {
54092       {
54093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54094       };
54095     }
54096   }
54097 }
54098
54099
54100 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_Stop(void * jarg1) {
54101   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54102
54103   arg1 = (Dali::Timer *)jarg1;
54104   {
54105     try {
54106       (arg1)->Stop();
54107     } catch (std::out_of_range& e) {
54108       {
54109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54110       };
54111     } catch (std::exception& e) {
54112       {
54113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54114       };
54115     } catch (...) {
54116       {
54117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54118       };
54119     }
54120   }
54121 }
54122
54123
54124 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54125   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54126   unsigned int arg2 ;
54127
54128   arg1 = (Dali::Timer *)jarg1;
54129   arg2 = (unsigned int)jarg2;
54130   {
54131     try {
54132       (arg1)->SetInterval(arg2);
54133     } catch (std::out_of_range& e) {
54134       {
54135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54136       };
54137     } catch (std::exception& e) {
54138       {
54139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54140       };
54141     } catch (...) {
54142       {
54143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54144       };
54145     }
54146   }
54147 }
54148
54149
54150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Timer_GetInterval(void * jarg1) {
54151   unsigned int jresult ;
54152   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54153   unsigned int result;
54154
54155   arg1 = (Dali::Timer *)jarg1;
54156   {
54157     try {
54158       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54159     } catch (std::out_of_range& e) {
54160       {
54161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54162       };
54163     } catch (std::exception& e) {
54164       {
54165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54166       };
54167     } catch (...) {
54168       {
54169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54170       };
54171     }
54172   }
54173   jresult = result;
54174   return jresult;
54175 }
54176
54177
54178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Timer_IsRunning(void * jarg1) {
54179   unsigned int jresult ;
54180   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54181   bool result;
54182
54183   arg1 = (Dali::Timer *)jarg1;
54184   {
54185     try {
54186       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54187     } catch (std::out_of_range& e) {
54188       {
54189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54190       };
54191     } catch (std::exception& e) {
54192       {
54193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54194       };
54195     } catch (...) {
54196       {
54197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54198       };
54199     }
54200   }
54201   jresult = result;
54202   return jresult;
54203 }
54204
54205
54206 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Timer_TickSignal(void * jarg1) {
54207   void * jresult ;
54208   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54209   Dali::Timer::TimerSignalType *result = 0 ;
54210
54211   arg1 = (Dali::Timer *)jarg1;
54212   {
54213     try {
54214       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54215     } catch (std::out_of_range& e) {
54216       {
54217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54218       };
54219     } catch (std::exception& e) {
54220       {
54221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54222       };
54223     } catch (...) {
54224       {
54225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54226       };
54227     }
54228   }
54229   jresult = (void *)result;
54230   return jresult;
54231 }
54232
54233
54234 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DragAndDropDetector() {
54235   void * jresult ;
54236   Dali::DragAndDropDetector *result = 0 ;
54237
54238   {
54239     try {
54240       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
54241     } catch (std::out_of_range& e) {
54242       {
54243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54244       };
54245     } catch (std::exception& e) {
54246       {
54247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (...) {
54250       {
54251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54252       };
54253     }
54254   }
54255   jresult = (void *)result;
54256   return jresult;
54257 }
54258
54259
54260 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DragAndDropDetector(void * jarg1) {
54261   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54262
54263   arg1 = (Dali::DragAndDropDetector *)jarg1;
54264   {
54265     try {
54266       delete arg1;
54267     } catch (std::out_of_range& e) {
54268       {
54269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54270       };
54271     } catch (std::exception& e) {
54272       {
54273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (...) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54278       };
54279     }
54280   }
54281 }
54282
54283
54284 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_GetContent(void * jarg1) {
54285   char * jresult ;
54286   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54287   std::string *result = 0 ;
54288
54289   arg1 = (Dali::DragAndDropDetector *)jarg1;
54290   {
54291     try {
54292       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
54293     } catch (std::out_of_range& e) {
54294       {
54295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54296       };
54297     } catch (std::exception& e) {
54298       {
54299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54300       };
54301     } catch (...) {
54302       {
54303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54304       };
54305     }
54306   }
54307   jresult = SWIG_csharp_string_callback(result->c_str());
54308   return jresult;
54309 }
54310
54311
54312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
54313   void * jresult ;
54314   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54315   Dali::Vector2 result;
54316
54317   arg1 = (Dali::DragAndDropDetector *)jarg1;
54318   {
54319     try {
54320       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
54321     } catch (std::out_of_range& e) {
54322       {
54323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54324       };
54325     } catch (std::exception& e) {
54326       {
54327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54332       };
54333     }
54334   }
54335   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
54336   return jresult;
54337 }
54338
54339
54340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_EnteredSignal(void * jarg1) {
54341   void * jresult ;
54342   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54343   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54344
54345   arg1 = (Dali::DragAndDropDetector *)jarg1;
54346   {
54347     try {
54348       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
54349     } catch (std::out_of_range& e) {
54350       {
54351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (std::exception& e) {
54354       {
54355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54356       };
54357     } catch (...) {
54358       {
54359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54360       };
54361     }
54362   }
54363   jresult = (void *)result;
54364   return jresult;
54365 }
54366
54367
54368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_ExitedSignal(void * jarg1) {
54369   void * jresult ;
54370   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54371   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54372
54373   arg1 = (Dali::DragAndDropDetector *)jarg1;
54374   {
54375     try {
54376       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
54377     } catch (std::out_of_range& e) {
54378       {
54379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54380       };
54381     } catch (std::exception& e) {
54382       {
54383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54384       };
54385     } catch (...) {
54386       {
54387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54388       };
54389     }
54390   }
54391   jresult = (void *)result;
54392   return jresult;
54393 }
54394
54395
54396 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_MovedSignal(void * jarg1) {
54397   void * jresult ;
54398   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54399   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54400
54401   arg1 = (Dali::DragAndDropDetector *)jarg1;
54402   {
54403     try {
54404       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
54405     } catch (std::out_of_range& e) {
54406       {
54407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54408       };
54409     } catch (std::exception& e) {
54410       {
54411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54412       };
54413     } catch (...) {
54414       {
54415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54416       };
54417     }
54418   }
54419   jresult = (void *)result;
54420   return jresult;
54421 }
54422
54423
54424 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_DroppedSignal(void * jarg1) {
54425   void * jresult ;
54426   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54427   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54428
54429   arg1 = (Dali::DragAndDropDetector *)jarg1;
54430   {
54431     try {
54432       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
54433     } catch (std::out_of_range& e) {
54434       {
54435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54436       };
54437     } catch (std::exception& e) {
54438       {
54439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54440       };
54441     } catch (...) {
54442       {
54443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54444       };
54445     }
54446   }
54447   jresult = (void *)result;
54448   return jresult;
54449 }
54450
54451
54452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationExtensions__SWIG_0() {
54453   void * jresult ;
54454   Dali::ApplicationExtensions *result = 0 ;
54455
54456   {
54457     try {
54458       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
54459     } catch (std::out_of_range& e) {
54460       {
54461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54462       };
54463     } catch (std::exception& e) {
54464       {
54465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54466       };
54467     } catch (...) {
54468       {
54469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54470       };
54471     }
54472   }
54473   jresult = (void *)result;
54474   return jresult;
54475 }
54476
54477
54478 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationExtensions__SWIG_1(void * jarg1) {
54479   void * jresult ;
54480   Dali::Application *arg1 = (Dali::Application *) 0 ;
54481   Dali::ApplicationExtensions *result = 0 ;
54482
54483   arg1 = (Dali::Application *)jarg1;
54484   {
54485     try {
54486       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
54487     } catch (std::out_of_range& e) {
54488       {
54489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (std::exception& e) {
54492       {
54493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54494       };
54495     } catch (...) {
54496       {
54497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54498       };
54499     }
54500   }
54501   jresult = (void *)result;
54502   return jresult;
54503 }
54504
54505
54506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationExtensions(void * jarg1) {
54507   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54508
54509   arg1 = (Dali::ApplicationExtensions *)jarg1;
54510   {
54511     try {
54512       delete arg1;
54513     } catch (std::out_of_range& e) {
54514       {
54515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54516       };
54517     } catch (std::exception& e) {
54518       {
54519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54520       };
54521     } catch (...) {
54522       {
54523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54524       };
54525     }
54526   }
54527 }
54528
54529
54530 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Init(void * jarg1) {
54531   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54532
54533   arg1 = (Dali::ApplicationExtensions *)jarg1;
54534   {
54535     try {
54536       (arg1)->Init();
54537     } catch (std::out_of_range& e) {
54538       {
54539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54540       };
54541     } catch (std::exception& e) {
54542       {
54543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54544       };
54545     } catch (...) {
54546       {
54547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54548       };
54549     }
54550   }
54551 }
54552
54553
54554 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Terminate(void * jarg1) {
54555   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54556
54557   arg1 = (Dali::ApplicationExtensions *)jarg1;
54558   {
54559     try {
54560       (arg1)->Terminate();
54561     } catch (std::out_of_range& e) {
54562       {
54563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54564       };
54565     } catch (std::exception& e) {
54566       {
54567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54568       };
54569     } catch (...) {
54570       {
54571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54572       };
54573     }
54574   }
54575 }
54576
54577
54578 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Pause(void * jarg1) {
54579   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54580
54581   arg1 = (Dali::ApplicationExtensions *)jarg1;
54582   {
54583     try {
54584       (arg1)->Pause();
54585     } catch (std::out_of_range& e) {
54586       {
54587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54588       };
54589     } catch (std::exception& e) {
54590       {
54591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54592       };
54593     } catch (...) {
54594       {
54595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54596       };
54597     }
54598   }
54599 }
54600
54601
54602 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_Resume(void * jarg1) {
54603   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54604
54605   arg1 = (Dali::ApplicationExtensions *)jarg1;
54606   {
54607     try {
54608       (arg1)->Resume();
54609     } catch (std::out_of_range& e) {
54610       {
54611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54612       };
54613     } catch (std::exception& e) {
54614       {
54615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54616       };
54617     } catch (...) {
54618       {
54619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54620       };
54621     }
54622   }
54623 }
54624
54625
54626 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationExtensions_LanguageChange(void * jarg1) {
54627   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54628
54629   arg1 = (Dali::ApplicationExtensions *)jarg1;
54630   {
54631     try {
54632       (arg1)->LanguageChange();
54633     } catch (std::out_of_range& e) {
54634       {
54635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54636       };
54637     } catch (std::exception& e) {
54638       {
54639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54640       };
54641     } catch (...) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54644       };
54645     }
54646   }
54647 }
54648
54649
54650 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
54651   void * jresult ;
54652   Dali::PositionSize arg1 ;
54653   std::string *arg2 = 0 ;
54654   bool arg3 ;
54655   Dali::PositionSize *argp1 ;
54656   Dali::Window result;
54657
54658   argp1 = (Dali::PositionSize *)jarg1;
54659   if (!argp1) {
54660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54661     return 0;
54662   }
54663   arg1 = *argp1;
54664   if (!jarg2) {
54665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54666     return 0;
54667   }
54668   std::string arg2_str(jarg2);
54669   arg2 = &arg2_str;
54670   arg3 = jarg3 ? true : false;
54671   {
54672     try {
54673       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
54674     } catch (std::out_of_range& e) {
54675       {
54676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54677       };
54678     } catch (std::exception& e) {
54679       {
54680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54681       };
54682     } catch (...) {
54683       {
54684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54685       };
54686     }
54687   }
54688   jresult = new Dali::Window((const Dali::Window &)result);
54689
54690   //argout typemap for const std::string&
54691
54692   return jresult;
54693 }
54694
54695
54696 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_1(void * jarg1, char * jarg2) {
54697   void * jresult ;
54698   Dali::PositionSize arg1 ;
54699   std::string *arg2 = 0 ;
54700   Dali::PositionSize *argp1 ;
54701   Dali::Window result;
54702
54703   argp1 = (Dali::PositionSize *)jarg1;
54704   if (!argp1) {
54705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54706     return 0;
54707   }
54708   arg1 = *argp1;
54709   if (!jarg2) {
54710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54711     return 0;
54712   }
54713   std::string arg2_str(jarg2);
54714   arg2 = &arg2_str;
54715   {
54716     try {
54717       result = Dali::Window::New(arg1,(std::string const &)*arg2);
54718     } catch (std::out_of_range& e) {
54719       {
54720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54721       };
54722     } catch (std::exception& e) {
54723       {
54724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54725       };
54726     } catch (...) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54729       };
54730     }
54731   }
54732   jresult = new Dali::Window((const Dali::Window &)result);
54733
54734   //argout typemap for const std::string&
54735
54736   return jresult;
54737 }
54738
54739
54740 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
54741   void * jresult ;
54742   Dali::PositionSize arg1 ;
54743   std::string *arg2 = 0 ;
54744   std::string *arg3 = 0 ;
54745   bool arg4 ;
54746   Dali::PositionSize *argp1 ;
54747   Dali::Window result;
54748
54749   argp1 = (Dali::PositionSize *)jarg1;
54750   if (!argp1) {
54751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54752     return 0;
54753   }
54754   arg1 = *argp1;
54755   if (!jarg2) {
54756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54757     return 0;
54758   }
54759   std::string arg2_str(jarg2);
54760   arg2 = &arg2_str;
54761   if (!jarg3) {
54762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54763     return 0;
54764   }
54765   std::string arg3_str(jarg3);
54766   arg3 = &arg3_str;
54767   arg4 = jarg4 ? true : false;
54768   {
54769     try {
54770       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
54771     } catch (std::out_of_range& e) {
54772       {
54773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54774       };
54775     } catch (std::exception& e) {
54776       {
54777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54778       };
54779     } catch (...) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54782       };
54783     }
54784   }
54785   jresult = new Dali::Window((const Dali::Window &)result);
54786
54787   //argout typemap for const std::string&
54788
54789
54790   //argout typemap for const std::string&
54791
54792   return jresult;
54793 }
54794
54795
54796 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
54797   void * jresult ;
54798   Dali::PositionSize arg1 ;
54799   std::string *arg2 = 0 ;
54800   std::string *arg3 = 0 ;
54801   Dali::PositionSize *argp1 ;
54802   Dali::Window result;
54803
54804   argp1 = (Dali::PositionSize *)jarg1;
54805   if (!argp1) {
54806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54807     return 0;
54808   }
54809   arg1 = *argp1;
54810   if (!jarg2) {
54811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54812     return 0;
54813   }
54814   std::string arg2_str(jarg2);
54815   arg2 = &arg2_str;
54816   if (!jarg3) {
54817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54818     return 0;
54819   }
54820   std::string arg3_str(jarg3);
54821   arg3 = &arg3_str;
54822   {
54823     try {
54824       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54825     } catch (std::out_of_range& e) {
54826       {
54827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54828       };
54829     } catch (std::exception& e) {
54830       {
54831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54832       };
54833     } catch (...) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54836       };
54837     }
54838   }
54839   jresult = new Dali::Window((const Dali::Window &)result);
54840
54841   //argout typemap for const std::string&
54842
54843
54844   //argout typemap for const std::string&
54845
54846   return jresult;
54847 }
54848
54849
54850 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Window__SWIG_0() {
54851   void * jresult ;
54852   Dali::Window *result = 0 ;
54853
54854   {
54855     try {
54856       result = (Dali::Window *)new Dali::Window();
54857     } catch (std::out_of_range& e) {
54858       {
54859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54860       };
54861     } catch (std::exception& e) {
54862       {
54863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54864       };
54865     } catch (...) {
54866       {
54867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54868       };
54869     }
54870   }
54871   jresult = (void *)result;
54872   return jresult;
54873 }
54874
54875
54876 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Window(void * jarg1) {
54877   Dali::Window *arg1 = (Dali::Window *) 0 ;
54878
54879   arg1 = (Dali::Window *)jarg1;
54880   {
54881     try {
54882       delete arg1;
54883     } catch (std::out_of_range& e) {
54884       {
54885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54886       };
54887     } catch (std::exception& e) {
54888       {
54889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54890       };
54891     } catch (...) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54894       };
54895     }
54896   }
54897 }
54898
54899
54900 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Window__SWIG_1(void * jarg1) {
54901   void * jresult ;
54902   Dali::Window *arg1 = 0 ;
54903   Dali::Window *result = 0 ;
54904
54905   arg1 = (Dali::Window *)jarg1;
54906   if (!arg1) {
54907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54908     return 0;
54909   }
54910   {
54911     try {
54912       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54920       };
54921     } catch (...) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54924       };
54925     }
54926   }
54927   jresult = (void *)result;
54928   return jresult;
54929 }
54930
54931
54932 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_Assign(void * jarg1, void * jarg2) {
54933   void * jresult ;
54934   Dali::Window *arg1 = (Dali::Window *) 0 ;
54935   Dali::Window *arg2 = 0 ;
54936   Dali::Window *result = 0 ;
54937
54938   arg1 = (Dali::Window *)jarg1;
54939   arg2 = (Dali::Window *)jarg2;
54940   if (!arg2) {
54941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54942     return 0;
54943   }
54944   {
54945     try {
54946       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
54947     } catch (std::out_of_range& e) {
54948       {
54949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54950       };
54951     } catch (std::exception& e) {
54952       {
54953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54954       };
54955     } catch (...) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54958       };
54959     }
54960   }
54961   jresult = (void *)result;
54962   return jresult;
54963 }
54964
54965
54966 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_ShowIndicator(void * jarg1, int jarg2) {
54967   Dali::Window *arg1 = (Dali::Window *) 0 ;
54968   Dali::Window::IndicatorVisibleMode arg2 ;
54969
54970   arg1 = (Dali::Window *)jarg1;
54971   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
54972   {
54973     try {
54974       (arg1)->ShowIndicator(arg2);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (...) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54986       };
54987     }
54988   }
54989 }
54990
54991
54992 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
54993   Dali::Window *arg1 = (Dali::Window *) 0 ;
54994   Dali::Window::IndicatorBgOpacity arg2 ;
54995
54996   arg1 = (Dali::Window *)jarg1;
54997   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
54998   {
54999     try {
55000       (arg1)->SetIndicatorBgOpacity(arg2);
55001     } catch (std::out_of_range& e) {
55002       {
55003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55004       };
55005     } catch (std::exception& e) {
55006       {
55007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (...) {
55010       {
55011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55012       };
55013     }
55014   }
55015 }
55016
55017
55018 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_RotateIndicator(void * jarg1, int jarg2) {
55019   Dali::Window *arg1 = (Dali::Window *) 0 ;
55020   Dali::Window::WindowOrientation arg2 ;
55021
55022   arg1 = (Dali::Window *)jarg1;
55023   arg2 = (Dali::Window::WindowOrientation)jarg2;
55024   {
55025     try {
55026       (arg1)->RotateIndicator(arg2);
55027     } catch (std::out_of_range& e) {
55028       {
55029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55030       };
55031     } catch (std::exception& e) {
55032       {
55033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55034       };
55035     } catch (...) {
55036       {
55037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55038       };
55039     }
55040   }
55041 }
55042
55043
55044 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
55045   Dali::Window *arg1 = (Dali::Window *) 0 ;
55046   std::string arg2 ;
55047   std::string arg3 ;
55048
55049   arg1 = (Dali::Window *)jarg1;
55050   if (!jarg2) {
55051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55052     return ;
55053   }
55054   (&arg2)->assign(jarg2);
55055   if (!jarg3) {
55056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55057     return ;
55058   }
55059   (&arg3)->assign(jarg3);
55060   {
55061     try {
55062       (arg1)->SetClass(arg2,arg3);
55063     } catch (std::out_of_range& e) {
55064       {
55065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55066       };
55067     } catch (std::exception& e) {
55068       {
55069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55070       };
55071     } catch (...) {
55072       {
55073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55074       };
55075     }
55076   }
55077 }
55078
55079
55080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Raise(void * jarg1) {
55081   Dali::Window *arg1 = (Dali::Window *) 0 ;
55082
55083   arg1 = (Dali::Window *)jarg1;
55084   {
55085     try {
55086       (arg1)->Raise();
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55098       };
55099     }
55100   }
55101 }
55102
55103
55104 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Lower(void * jarg1) {
55105   Dali::Window *arg1 = (Dali::Window *) 0 ;
55106
55107   arg1 = (Dali::Window *)jarg1;
55108   {
55109     try {
55110       (arg1)->Lower();
55111     } catch (std::out_of_range& e) {
55112       {
55113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55114       };
55115     } catch (std::exception& e) {
55116       {
55117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55118       };
55119     } catch (...) {
55120       {
55121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55122       };
55123     }
55124   }
55125 }
55126
55127
55128 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_Activate(void * jarg1) {
55129   Dali::Window *arg1 = (Dali::Window *) 0 ;
55130
55131   arg1 = (Dali::Window *)jarg1;
55132   {
55133     try {
55134       (arg1)->Activate();
55135     } catch (std::out_of_range& e) {
55136       {
55137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55138       };
55139     } catch (std::exception& e) {
55140       {
55141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55146       };
55147     }
55148   }
55149 }
55150
55151
55152 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
55153   Dali::Window *arg1 = (Dali::Window *) 0 ;
55154   Dali::Window::WindowOrientation arg2 ;
55155
55156   arg1 = (Dali::Window *)jarg1;
55157   arg2 = (Dali::Window::WindowOrientation)jarg2;
55158   {
55159     try {
55160       (arg1)->AddAvailableOrientation(arg2);
55161     } catch (std::out_of_range& e) {
55162       {
55163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55164       };
55165     } catch (std::exception& e) {
55166       {
55167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55168       };
55169     } catch (...) {
55170       {
55171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55172       };
55173     }
55174   }
55175 }
55176
55177
55178 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
55179   Dali::Window *arg1 = (Dali::Window *) 0 ;
55180   Dali::Window::WindowOrientation arg2 ;
55181
55182   arg1 = (Dali::Window *)jarg1;
55183   arg2 = (Dali::Window::WindowOrientation)jarg2;
55184   {
55185     try {
55186       (arg1)->RemoveAvailableOrientation(arg2);
55187     } catch (std::out_of_range& e) {
55188       {
55189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55190       };
55191     } catch (std::exception& e) {
55192       {
55193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55194       };
55195     } catch (...) {
55196       {
55197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55198       };
55199     }
55200   }
55201 }
55202
55203
55204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
55205   Dali::Window *arg1 = (Dali::Window *) 0 ;
55206   Dali::Window::WindowOrientation arg2 ;
55207
55208   arg1 = (Dali::Window *)jarg1;
55209   arg2 = (Dali::Window::WindowOrientation)jarg2;
55210   {
55211     try {
55212       (arg1)->SetPreferredOrientation(arg2);
55213     } catch (std::out_of_range& e) {
55214       {
55215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55216       };
55217     } catch (std::exception& e) {
55218       {
55219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55220       };
55221     } catch (...) {
55222       {
55223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55224       };
55225     }
55226   }
55227 }
55228
55229
55230 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Window_GetPreferredOrientation(void * jarg1) {
55231   int jresult ;
55232   Dali::Window *arg1 = (Dali::Window *) 0 ;
55233   Dali::Window::WindowOrientation result;
55234
55235   arg1 = (Dali::Window *)jarg1;
55236   {
55237     try {
55238       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
55239     } catch (std::out_of_range& e) {
55240       {
55241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55242       };
55243     } catch (std::exception& e) {
55244       {
55245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55246       };
55247     } catch (...) {
55248       {
55249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55250       };
55251     }
55252   }
55253   jresult = (int)result;
55254   return jresult;
55255 }
55256
55257
55258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_GetDragAndDropDetector(void * jarg1) {
55259   void * jresult ;
55260   Dali::Window *arg1 = (Dali::Window *) 0 ;
55261   Dali::DragAndDropDetector result;
55262
55263   arg1 = (Dali::Window *)jarg1;
55264   {
55265     try {
55266       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (...) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55278       };
55279     }
55280   }
55281   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
55282   return jresult;
55283 }
55284
55285
55286 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_GetNativeHandle(void * jarg1) {
55287   void * jresult ;
55288   Dali::Window *arg1 = (Dali::Window *) 0 ;
55289   Dali::Any result;
55290
55291   arg1 = (Dali::Window *)jarg1;
55292   {
55293     try {
55294       result = ((Dali::Window const *)arg1)->GetNativeHandle();
55295     } catch (std::out_of_range& e) {
55296       {
55297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55298       };
55299     } catch (std::exception& e) {
55300       {
55301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55302       };
55303     } catch (...) {
55304       {
55305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55306       };
55307     }
55308   }
55309   jresult = new Dali::Any((const Dali::Any &)result);
55310   return jresult;
55311 }
55312
55313
55314 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
55315   void * jresult ;
55316   Dali::Window *arg1 = (Dali::Window *) 0 ;
55317   Dali::Window::IndicatorSignalType *result = 0 ;
55318
55319   arg1 = (Dali::Window *)jarg1;
55320   {
55321     try {
55322       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
55323     } catch (std::out_of_range& e) {
55324       {
55325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55326       };
55327     } catch (std::exception& e) {
55328       {
55329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55330       };
55331     } catch (...) {
55332       {
55333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55334       };
55335     }
55336   }
55337   jresult = (void *)result;
55338   return jresult;
55339 }
55340
55341
55342 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_0() {
55343   void * jresult ;
55344   Dali::Application result;
55345
55346   {
55347     try {
55348       result = Dali::Application::New();
55349     } catch (std::out_of_range& e) {
55350       {
55351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55352       };
55353     } catch (std::exception& e) {
55354       {
55355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55356       };
55357     } catch (...) {
55358       {
55359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55360       };
55361     }
55362   }
55363   jresult = new Dali::Application((const Dali::Application &)result);
55364   return jresult;
55365 }
55366
55367
55368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_1(int jarg1) {
55369   void * jresult ;
55370   int *arg1 = (int *) 0 ;
55371   char ***arg2 ;
55372   Dali::Application result;
55373
55374   {
55375     // Todo generate argv data from the C# args
55376     char **array;         // two dimensional array
55377     int numStrings = 1;     // number of strings
55378     int stringLength = 30;      // max string length.
55379     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55380     argV = array;
55381
55382     // allocate the string data
55383     for( int i=0; i < numStrings; i++)
55384     {
55385       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55386     }
55387     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55388
55389     strcpy( array[0], "dali-csharp-app");
55390
55391     arg1 = &argC;
55392     arg2 = &argV;
55393   }
55394   {
55395     try {
55396       result = Dali::Application::New(arg1,arg2);
55397     } catch (std::out_of_range& e) {
55398       {
55399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55400       };
55401     } catch (std::exception& e) {
55402       {
55403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55404       };
55405     } catch (...) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55408       };
55409     }
55410   }
55411   jresult = new Dali::Application((const Dali::Application &)result);
55412   return jresult;
55413 }
55414
55415
55416 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_2(int jarg1, char * jarg3) {
55417   void * jresult ;
55418   int *arg1 = (int *) 0 ;
55419   char ***arg2 ;
55420   std::string *arg3 = 0 ;
55421   Dali::Application result;
55422
55423   {
55424     // Todo generate argv data from the C# args
55425     char **array;         // two dimensional array
55426     int numStrings = 1;     // number of strings
55427     int stringLength = 30;      // max string length.
55428     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55429     argV = array;
55430
55431     // allocate the string data
55432     for( int i=0; i < numStrings; i++)
55433     {
55434       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55435     }
55436     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55437
55438     strcpy( array[0], "dali-csharp-app");
55439
55440     arg1 = &argC;
55441     arg2 = &argV;
55442   }
55443   if (!jarg3) {
55444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55445     return 0;
55446   }
55447   std::string arg3_str(jarg3);
55448   arg3 = &arg3_str;
55449   {
55450     try {
55451       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55452     } catch (std::out_of_range& e) {
55453       {
55454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55455       };
55456     } catch (std::exception& e) {
55457       {
55458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55459       };
55460     } catch (...) {
55461       {
55462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55463       };
55464     }
55465   }
55466   jresult = new Dali::Application((const Dali::Application &)result);
55467
55468   //argout typemap for const std::string&
55469
55470   return jresult;
55471 }
55472
55473
55474 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55475   void * jresult ;
55476   int *arg1 = (int *) 0 ;
55477   char ***arg2 ;
55478   std::string *arg3 = 0 ;
55479   Dali::Application::WINDOW_MODE arg4 ;
55480   Dali::Application result;
55481
55482   {
55483     // Todo generate argv data from the C# args
55484     char **array;         // two dimensional array
55485     int numStrings = 1;     // number of strings
55486     int stringLength = 30;      // max string length.
55487     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55488     argV = array;
55489
55490     // allocate the string data
55491     for( int i=0; i < numStrings; i++)
55492     {
55493       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55494     }
55495     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55496
55497     strcpy( array[0], "dali-csharp-app");
55498
55499     arg1 = &argC;
55500     arg2 = &argV;
55501   }
55502   if (!jarg3) {
55503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55504     return 0;
55505   }
55506   std::string arg3_str(jarg3);
55507   arg3 = &arg3_str;
55508   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55509   {
55510     try {
55511       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55512     } catch (std::out_of_range& e) {
55513       {
55514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55515       };
55516     } catch (std::exception& e) {
55517       {
55518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55519       };
55520     } catch (...) {
55521       {
55522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55523       };
55524     }
55525   }
55526   jresult = new Dali::Application((const Dali::Application &)result);
55527
55528   //argout typemap for const std::string&
55529
55530   return jresult;
55531 }
55532
55533
55534 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Application__SWIG_0() {
55535   void * jresult ;
55536   Dali::Application *result = 0 ;
55537
55538   {
55539     try {
55540       result = (Dali::Application *)new Dali::Application();
55541     } catch (std::out_of_range& e) {
55542       {
55543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (std::exception& e) {
55546       {
55547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55548       };
55549     } catch (...) {
55550       {
55551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55552       };
55553     }
55554   }
55555   jresult = (void *)result;
55556   return jresult;
55557 }
55558
55559
55560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Application__SWIG_1(void * jarg1) {
55561   void * jresult ;
55562   Dali::Application *arg1 = 0 ;
55563   Dali::Application *result = 0 ;
55564
55565   arg1 = (Dali::Application *)jarg1;
55566   if (!arg1) {
55567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55568     return 0;
55569   }
55570   {
55571     try {
55572       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55573     } catch (std::out_of_range& e) {
55574       {
55575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55576       };
55577     } catch (std::exception& e) {
55578       {
55579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (...) {
55582       {
55583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55584       };
55585     }
55586   }
55587   jresult = (void *)result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_Assign(void * jarg1, void * jarg2) {
55593   void * jresult ;
55594   Dali::Application *arg1 = (Dali::Application *) 0 ;
55595   Dali::Application *arg2 = 0 ;
55596   Dali::Application *result = 0 ;
55597
55598   arg1 = (Dali::Application *)jarg1;
55599   arg2 = (Dali::Application *)jarg2;
55600   if (!arg2) {
55601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55602     return 0;
55603   }
55604   {
55605     try {
55606       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55607     } catch (std::out_of_range& e) {
55608       {
55609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55610       };
55611     } catch (std::exception& e) {
55612       {
55613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55618       };
55619     }
55620   }
55621   jresult = (void *)result;
55622   return jresult;
55623 }
55624
55625
55626 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Application(void * jarg1) {
55627   Dali::Application *arg1 = (Dali::Application *) 0 ;
55628
55629   arg1 = (Dali::Application *)jarg1;
55630   {
55631     try {
55632       delete arg1;
55633     } catch (std::out_of_range& e) {
55634       {
55635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55636       };
55637     } catch (std::exception& e) {
55638       {
55639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55640       };
55641     } catch (...) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55644       };
55645     }
55646   }
55647 }
55648
55649
55650 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_MainLoop__SWIG_0(void * jarg1) {
55651   Dali::Application *arg1 = (Dali::Application *) 0 ;
55652
55653   arg1 = (Dali::Application *)jarg1;
55654   {
55655     try {
55656       (arg1)->MainLoop();
55657     } catch (std::out_of_range& e) {
55658       {
55659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55660       };
55661     } catch (std::exception& e) {
55662       {
55663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55664       };
55665     } catch (...) {
55666       {
55667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55668       };
55669     }
55670   }
55671 }
55672
55673
55674 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55675   Dali::Application *arg1 = (Dali::Application *) 0 ;
55676   Configuration::ContextLoss arg2 ;
55677   Configuration::ContextLoss *argp2 ;
55678
55679   arg1 = (Dali::Application *)jarg1;
55680   argp2 = (Configuration::ContextLoss *)jarg2;
55681   if (!argp2) {
55682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55683     return ;
55684   }
55685   arg2 = *argp2;
55686   {
55687     try {
55688       (arg1)->MainLoop(arg2);
55689     } catch (std::out_of_range& e) {
55690       {
55691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55692       };
55693     } catch (std::exception& e) {
55694       {
55695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55696       };
55697     } catch (...) {
55698       {
55699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55700       };
55701     }
55702   }
55703 }
55704
55705
55706 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_Lower(void * jarg1) {
55707   Dali::Application *arg1 = (Dali::Application *) 0 ;
55708
55709   arg1 = (Dali::Application *)jarg1;
55710   {
55711     try {
55712       (arg1)->Lower();
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (...) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55724       };
55725     }
55726   }
55727 }
55728
55729
55730 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_Quit(void * jarg1) {
55731   Dali::Application *arg1 = (Dali::Application *) 0 ;
55732
55733   arg1 = (Dali::Application *)jarg1;
55734   {
55735     try {
55736       (arg1)->Quit();
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55744       };
55745     } catch (...) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55748       };
55749     }
55750   }
55751 }
55752
55753
55754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Application_AddIdle(void * jarg1, void * jarg2) {
55755   unsigned int jresult ;
55756   Dali::Application *arg1 = (Dali::Application *) 0 ;
55757   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55758   bool result;
55759
55760   arg1 = (Dali::Application *)jarg1;
55761   arg2 = (Dali::CallbackBase *)jarg2;
55762   {
55763     try {
55764       result = (bool)(arg1)->AddIdle(arg2);
55765     } catch (std::out_of_range& e) {
55766       {
55767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55768       };
55769     } catch (std::exception& e) {
55770       {
55771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55772       };
55773     } catch (...) {
55774       {
55775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55776       };
55777     }
55778   }
55779   jresult = result;
55780   return jresult;
55781 }
55782
55783
55784 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_GetWindow(void * jarg1) {
55785   void * jresult ;
55786   Dali::Application *arg1 = (Dali::Application *) 0 ;
55787   Dali::Window result;
55788
55789   arg1 = (Dali::Application *)jarg1;
55790   {
55791     try {
55792       result = (arg1)->GetWindow();
55793     } catch (std::out_of_range& e) {
55794       {
55795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (std::exception& e) {
55798       {
55799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (...) {
55802       {
55803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55804       };
55805     }
55806   }
55807   jresult = new Dali::Window((const Dali::Window &)result);
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55813   Dali::Application *arg1 = (Dali::Application *) 0 ;
55814   Dali::PositionSize arg2 ;
55815   std::string *arg3 = 0 ;
55816   Dali::PositionSize *argp2 ;
55817
55818   arg1 = (Dali::Application *)jarg1;
55819   argp2 = (Dali::PositionSize *)jarg2;
55820   if (!argp2) {
55821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55822     return ;
55823   }
55824   arg2 = *argp2;
55825   if (!jarg3) {
55826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55827     return ;
55828   }
55829   std::string arg3_str(jarg3);
55830   arg3 = &arg3_str;
55831   {
55832     try {
55833       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (...) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55845       };
55846     }
55847   }
55848
55849   //argout typemap for const std::string&
55850
55851 }
55852
55853
55854 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Application_GetResourcePath() {
55855   char * jresult ;
55856   std::string result;
55857
55858   {
55859     try {
55860       result = Dali::Application::GetResourcePath();
55861     } catch (std::out_of_range& e) {
55862       {
55863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55864       };
55865     } catch (std::exception& e) {
55866       {
55867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55868       };
55869     } catch (...) {
55870       {
55871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55872       };
55873     }
55874   }
55875   jresult = SWIG_csharp_string_callback((&result)->c_str());
55876   return jresult;
55877 }
55878
55879
55880 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_SetViewMode(void * jarg1, int jarg2) {
55881   Dali::Application *arg1 = (Dali::Application *) 0 ;
55882   Dali::ViewMode arg2 ;
55883
55884   arg1 = (Dali::Application *)jarg1;
55885   arg2 = (Dali::ViewMode)jarg2;
55886   {
55887     try {
55888       (arg1)->SetViewMode(arg2);
55889     } catch (std::out_of_range& e) {
55890       {
55891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55892       };
55893     } catch (std::exception& e) {
55894       {
55895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55896       };
55897     } catch (...) {
55898       {
55899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55900       };
55901     }
55902   }
55903 }
55904
55905
55906 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Application_GetViewMode(void * jarg1) {
55907   int jresult ;
55908   Dali::Application *arg1 = (Dali::Application *) 0 ;
55909   Dali::ViewMode result;
55910
55911   arg1 = (Dali::Application *)jarg1;
55912   {
55913     try {
55914       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55915     } catch (std::out_of_range& e) {
55916       {
55917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55918       };
55919     } catch (std::exception& e) {
55920       {
55921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55922       };
55923     } catch (...) {
55924       {
55925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55926       };
55927     }
55928   }
55929   jresult = (int)result;
55930   return jresult;
55931 }
55932
55933
55934 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Application_SetStereoBase(void * jarg1, float jarg2) {
55935   Dali::Application *arg1 = (Dali::Application *) 0 ;
55936   float arg2 ;
55937
55938   arg1 = (Dali::Application *)jarg1;
55939   arg2 = (float)jarg2;
55940   {
55941     try {
55942       (arg1)->SetStereoBase(arg2);
55943     } catch (std::out_of_range& e) {
55944       {
55945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55946       };
55947     } catch (std::exception& e) {
55948       {
55949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55950       };
55951     } catch (...) {
55952       {
55953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55954       };
55955     }
55956   }
55957 }
55958
55959
55960 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Application_GetStereoBase(void * jarg1) {
55961   float jresult ;
55962   Dali::Application *arg1 = (Dali::Application *) 0 ;
55963   float result;
55964
55965   arg1 = (Dali::Application *)jarg1;
55966   {
55967     try {
55968       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55969     } catch (std::out_of_range& e) {
55970       {
55971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55972       };
55973     } catch (std::exception& e) {
55974       {
55975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55976       };
55977     } catch (...) {
55978       {
55979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55980       };
55981     }
55982   }
55983   jresult = result;
55984   return jresult;
55985 }
55986
55987
55988 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_InitSignal(void * jarg1) {
55989   void * jresult ;
55990   Dali::Application *arg1 = (Dali::Application *) 0 ;
55991   Dali::Application::AppSignalType *result = 0 ;
55992
55993   arg1 = (Dali::Application *)jarg1;
55994   {
55995     try {
55996       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55997     } catch (std::out_of_range& e) {
55998       {
55999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56000       };
56001     } catch (std::exception& e) {
56002       {
56003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (...) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56008       };
56009     }
56010   }
56011   jresult = (void *)result;
56012   return jresult;
56013 }
56014
56015
56016 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_TerminateSignal(void * jarg1) {
56017   void * jresult ;
56018   Dali::Application *arg1 = (Dali::Application *) 0 ;
56019   Dali::Application::AppSignalType *result = 0 ;
56020
56021   arg1 = (Dali::Application *)jarg1;
56022   {
56023     try {
56024       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
56025     } catch (std::out_of_range& e) {
56026       {
56027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56028       };
56029     } catch (std::exception& e) {
56030       {
56031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56032       };
56033     } catch (...) {
56034       {
56035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56036       };
56037     }
56038   }
56039   jresult = (void *)result;
56040   return jresult;
56041 }
56042
56043
56044 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_PauseSignal(void * jarg1) {
56045   void * jresult ;
56046   Dali::Application *arg1 = (Dali::Application *) 0 ;
56047   Dali::Application::AppSignalType *result = 0 ;
56048
56049   arg1 = (Dali::Application *)jarg1;
56050   {
56051     try {
56052       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
56053     } catch (std::out_of_range& e) {
56054       {
56055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (std::exception& e) {
56058       {
56059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56060       };
56061     } catch (...) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56064       };
56065     }
56066   }
56067   jresult = (void *)result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResumeSignal(void * jarg1) {
56073   void * jresult ;
56074   Dali::Application *arg1 = (Dali::Application *) 0 ;
56075   Dali::Application::AppSignalType *result = 0 ;
56076
56077   arg1 = (Dali::Application *)jarg1;
56078   {
56079     try {
56080       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
56081     } catch (std::out_of_range& e) {
56082       {
56083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (std::exception& e) {
56086       {
56087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56088       };
56089     } catch (...) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56092       };
56093     }
56094   }
56095   jresult = (void *)result;
56096   return jresult;
56097 }
56098
56099
56100 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResetSignal(void * jarg1) {
56101   void * jresult ;
56102   Dali::Application *arg1 = (Dali::Application *) 0 ;
56103   Dali::Application::AppSignalType *result = 0 ;
56104
56105   arg1 = (Dali::Application *)jarg1;
56106   {
56107     try {
56108       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
56109     } catch (std::out_of_range& e) {
56110       {
56111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56112       };
56113     } catch (std::exception& e) {
56114       {
56115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56116       };
56117     } catch (...) {
56118       {
56119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56120       };
56121     }
56122   }
56123   jresult = (void *)result;
56124   return jresult;
56125 }
56126
56127
56128 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_ResizeSignal(void * jarg1) {
56129   void * jresult ;
56130   Dali::Application *arg1 = (Dali::Application *) 0 ;
56131   Dali::Application::AppSignalType *result = 0 ;
56132
56133   arg1 = (Dali::Application *)jarg1;
56134   {
56135     try {
56136       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
56137     } catch (std::out_of_range& e) {
56138       {
56139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (std::exception& e) {
56142       {
56143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56144       };
56145     } catch (...) {
56146       {
56147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56148       };
56149     }
56150   }
56151   jresult = (void *)result;
56152   return jresult;
56153 }
56154
56155
56156 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_AppControlSignal(void * jarg1) {
56157   void * jresult ;
56158   Dali::Application *arg1 = (Dali::Application *) 0 ;
56159   Dali::Application::AppControlSignalType *result = 0 ;
56160
56161   arg1 = (Dali::Application *)jarg1;
56162   {
56163     try {
56164       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
56165     } catch (std::out_of_range& e) {
56166       {
56167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56168       };
56169     } catch (std::exception& e) {
56170       {
56171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56172       };
56173     } catch (...) {
56174       {
56175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56176       };
56177     }
56178   }
56179   jresult = (void *)result;
56180   return jresult;
56181 }
56182
56183
56184 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_LanguageChangedSignal(void * jarg1) {
56185   void * jresult ;
56186   Dali::Application *arg1 = (Dali::Application *) 0 ;
56187   Dali::Application::AppSignalType *result = 0 ;
56188
56189   arg1 = (Dali::Application *)jarg1;
56190   {
56191     try {
56192       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56193     } catch (std::out_of_range& e) {
56194       {
56195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56196       };
56197     } catch (std::exception& e) {
56198       {
56199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (...) {
56202       {
56203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56204       };
56205     }
56206   }
56207   jresult = (void *)result;
56208   return jresult;
56209 }
56210
56211
56212 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_RegionChangedSignal(void * jarg1) {
56213   void * jresult ;
56214   Dali::Application *arg1 = (Dali::Application *) 0 ;
56215   Dali::Application::AppSignalType *result = 0 ;
56216
56217   arg1 = (Dali::Application *)jarg1;
56218   {
56219     try {
56220       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56221     } catch (std::out_of_range& e) {
56222       {
56223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (std::exception& e) {
56226       {
56227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (...) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56232       };
56233     }
56234   }
56235   jresult = (void *)result;
56236   return jresult;
56237 }
56238
56239
56240 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_BatteryLowSignal(void * jarg1) {
56241   void * jresult ;
56242   Dali::Application *arg1 = (Dali::Application *) 0 ;
56243   Dali::Application::AppSignalType *result = 0 ;
56244
56245   arg1 = (Dali::Application *)jarg1;
56246   {
56247     try {
56248       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56249     } catch (std::out_of_range& e) {
56250       {
56251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56252       };
56253     } catch (std::exception& e) {
56254       {
56255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56256       };
56257     } catch (...) {
56258       {
56259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56260       };
56261     }
56262   }
56263   jresult = (void *)result;
56264   return jresult;
56265 }
56266
56267
56268 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Application_MemoryLowSignal(void * jarg1) {
56269   void * jresult ;
56270   Dali::Application *arg1 = (Dali::Application *) 0 ;
56271   Dali::Application::AppSignalType *result = 0 ;
56272
56273   arg1 = (Dali::Application *)jarg1;
56274   {
56275     try {
56276       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56277     } catch (std::out_of_range& e) {
56278       {
56279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56280       };
56281     } catch (std::exception& e) {
56282       {
56283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56284       };
56285     } catch (...) {
56286       {
56287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56288       };
56289     }
56290   }
56291   jresult = (void *)result;
56292   return jresult;
56293 }
56294
56295
56296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ApplicationSignal_Empty(void * jarg1) {
56297   unsigned int jresult ;
56298   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56299   bool result;
56300
56301   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56302   {
56303     try {
56304       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56305     } catch (std::out_of_range& e) {
56306       {
56307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56308       };
56309     } catch (std::exception& e) {
56310       {
56311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56316       };
56317     }
56318   }
56319   jresult = result;
56320   return jresult;
56321 }
56322
56323
56324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ApplicationSignal_GetConnectionCount(void * jarg1) {
56325   unsigned long jresult ;
56326   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56327   std::size_t result;
56328
56329   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56330   {
56331     try {
56332       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56333     } catch (std::out_of_range& e) {
56334       {
56335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56336       };
56337     } catch (std::exception& e) {
56338       {
56339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56340       };
56341     } catch (...) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56344       };
56345     }
56346   }
56347   jresult = (unsigned long)result;
56348   return jresult;
56349 }
56350
56351
56352 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56353   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56354   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56355
56356   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56357   arg2 = (void (*)(Dali::Application &))jarg2;
56358   {
56359     try {
56360       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56361     } catch (std::out_of_range& e) {
56362       {
56363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56364       };
56365     } catch (std::exception& e) {
56366       {
56367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56368       };
56369     } catch (...) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56372       };
56373     }
56374   }
56375 }
56376
56377
56378 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56379   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56380   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56381
56382   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56383   arg2 = (void (*)(Dali::Application &))jarg2;
56384   {
56385     try {
56386       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56387     } catch (std::out_of_range& e) {
56388       {
56389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56390       };
56391     } catch (std::exception& e) {
56392       {
56393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56394       };
56395     } catch (...) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56398       };
56399     }
56400   }
56401 }
56402
56403
56404 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56405   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56406   Dali::Application *arg2 = 0 ;
56407
56408   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56409   arg2 = (Dali::Application *)jarg2;
56410   if (!arg2) {
56411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56412     return ;
56413   }
56414   {
56415     try {
56416       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56417     } catch (std::out_of_range& e) {
56418       {
56419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56420       };
56421     } catch (std::exception& e) {
56422       {
56423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56424       };
56425     } catch (...) {
56426       {
56427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56428       };
56429     }
56430   }
56431 }
56432
56433
56434 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationSignal() {
56435   void * jresult ;
56436   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56437
56438   {
56439     try {
56440       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56441     } catch (std::out_of_range& e) {
56442       {
56443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56444       };
56445     } catch (std::exception& e) {
56446       {
56447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56448       };
56449     } catch (...) {
56450       {
56451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56452       };
56453     }
56454   }
56455   jresult = (void *)result;
56456   return jresult;
56457 }
56458
56459
56460 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationSignal(void * jarg1) {
56461   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56462
56463   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56464   {
56465     try {
56466       delete arg1;
56467     } catch (std::out_of_range& e) {
56468       {
56469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56470       };
56471     } catch (std::exception& e) {
56472       {
56473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56474       };
56475     } catch (...) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56478       };
56479     }
56480   }
56481 }
56482
56483
56484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Empty(void * jarg1) {
56485   unsigned int jresult ;
56486   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56487   bool result;
56488
56489   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56490   {
56491     try {
56492       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56493     } catch (std::out_of_range& e) {
56494       {
56495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56496       };
56497     } catch (std::exception& e) {
56498       {
56499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56500       };
56501     } catch (...) {
56502       {
56503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56504       };
56505     }
56506   }
56507   jresult = result;
56508   return jresult;
56509 }
56510
56511
56512 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56513   unsigned long jresult ;
56514   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56515   std::size_t result;
56516
56517   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56518   {
56519     try {
56520       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56532       };
56533     }
56534   }
56535   jresult = (unsigned long)result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56541   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56542   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56543
56544   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56545   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56546   {
56547     try {
56548       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56556       };
56557     } catch (...) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56560       };
56561     }
56562   }
56563 }
56564
56565
56566 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56567   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56568   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56569
56570   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56571   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56572   {
56573     try {
56574       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56575     } catch (std::out_of_range& e) {
56576       {
56577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56578       };
56579     } catch (std::exception& e) {
56580       {
56581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56582       };
56583     } catch (...) {
56584       {
56585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56586       };
56587     }
56588   }
56589 }
56590
56591
56592 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56593   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56594   Dali::Application *arg2 = 0 ;
56595   void *arg3 = (void *) 0 ;
56596
56597   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56598   arg2 = (Dali::Application *)jarg2;
56599   if (!arg2) {
56600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56601     return ;
56602   }
56603   arg3 = jarg3;
56604   {
56605     try {
56606       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56607     } catch (std::out_of_range& e) {
56608       {
56609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56610       };
56611     } catch (std::exception& e) {
56612       {
56613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (...) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56618       };
56619     }
56620   }
56621 }
56622
56623
56624 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ApplicationControlSignal() {
56625   void * jresult ;
56626   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56627
56628   {
56629     try {
56630       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56631     } catch (std::out_of_range& e) {
56632       {
56633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (std::exception& e) {
56636       {
56637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56638       };
56639     } catch (...) {
56640       {
56641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56642       };
56643     }
56644   }
56645   jresult = (void *)result;
56646   return jresult;
56647 }
56648
56649
56650 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ApplicationControlSignal(void * jarg1) {
56651   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56652
56653   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56654   {
56655     try {
56656       delete arg1;
56657     } catch (std::out_of_range& e) {
56658       {
56659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56660       };
56661     } catch (std::exception& e) {
56662       {
56663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56664       };
56665     } catch (...) {
56666       {
56667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56668       };
56669     }
56670   }
56671 }
56672
56673
56674 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TimerSignalType() {
56675   void * jresult ;
56676   Dali::Signal< bool () > *result = 0 ;
56677
56678   {
56679     try {
56680       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56681     } catch (std::out_of_range& e) {
56682       {
56683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (std::exception& e) {
56686       {
56687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56688       };
56689     } catch (...) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56692       };
56693     }
56694   }
56695   jresult = (void *)result;
56696   return jresult;
56697 }
56698
56699
56700 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TimerSignalType(void * jarg1) {
56701   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56702
56703   arg1 = (Dali::Signal< bool () > *)jarg1;
56704   {
56705     try {
56706       delete arg1;
56707     } catch (std::out_of_range& e) {
56708       {
56709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56710       };
56711     } catch (std::exception& e) {
56712       {
56713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56714       };
56715     } catch (...) {
56716       {
56717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56718       };
56719     }
56720   }
56721 }
56722
56723
56724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TimerSignalType_Empty(void * jarg1) {
56725   unsigned int jresult ;
56726   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56727   bool result;
56728
56729   arg1 = (Dali::Signal< bool () > *)jarg1;
56730   {
56731     try {
56732       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
56733     } catch (std::out_of_range& e) {
56734       {
56735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56736       };
56737     } catch (std::exception& e) {
56738       {
56739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56740       };
56741     } catch (...) {
56742       {
56743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56744       };
56745     }
56746   }
56747   jresult = result;
56748   return jresult;
56749 }
56750
56751
56752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TimerSignalType_GetConnectionCount(void * jarg1) {
56753   unsigned long jresult ;
56754   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56755   std::size_t result;
56756
56757   arg1 = (Dali::Signal< bool () > *)jarg1;
56758   {
56759     try {
56760       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
56761     } catch (std::out_of_range& e) {
56762       {
56763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (std::exception& e) {
56766       {
56767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56768       };
56769     } catch (...) {
56770       {
56771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56772       };
56773     }
56774   }
56775   jresult = (unsigned long)result;
56776   return jresult;
56777 }
56778
56779
56780 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
56781   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56782   bool (*arg2)() = (bool (*)()) 0 ;
56783
56784   arg1 = (Dali::Signal< bool () > *)jarg1;
56785   arg2 = (bool (*)())jarg2;
56786   {
56787     try {
56788       (arg1)->Connect(arg2);
56789     } catch (std::out_of_range& e) {
56790       {
56791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56792       };
56793     } catch (std::exception& e) {
56794       {
56795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56796       };
56797     } catch (...) {
56798       {
56799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56800       };
56801     }
56802   }
56803 }
56804
56805
56806 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56807   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56808   bool (*arg2)() = (bool (*)()) 0 ;
56809
56810   arg1 = (Dali::Signal< bool () > *)jarg1;
56811   arg2 = (bool (*)())jarg2;
56812   {
56813     try {
56814       (arg1)->Disconnect(arg2);
56815     } catch (std::out_of_range& e) {
56816       {
56817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56818       };
56819     } catch (std::exception& e) {
56820       {
56821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56822       };
56823     } catch (...) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56826       };
56827     }
56828   }
56829 }
56830
56831
56832 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TimerSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
56833   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56834   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
56835   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
56836
56837   arg1 = (Dali::Signal< bool () > *)jarg1;
56838   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
56839   arg3 = (Dali::FunctorDelegate *)jarg3;
56840   {
56841     try {
56842       (arg1)->Connect(arg2,arg3);
56843     } catch (std::out_of_range& e) {
56844       {
56845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56846       };
56847     } catch (std::exception& e) {
56848       {
56849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56850       };
56851     } catch (...) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56854       };
56855     }
56856   }
56857 }
56858
56859
56860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TimerSignalType_Emit(void * jarg1) {
56861   unsigned int jresult ;
56862   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56863   bool result;
56864
56865   arg1 = (Dali::Signal< bool () > *)jarg1;
56866   {
56867     try {
56868       result = (bool)(arg1)->Emit();
56869     } catch (std::out_of_range& e) {
56870       {
56871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56872       };
56873     } catch (std::exception& e) {
56874       {
56875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56876       };
56877     } catch (...) {
56878       {
56879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56880       };
56881     }
56882   }
56883   jresult = result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VISUAL_PROPERTY_TYPE_get() {
56889   int jresult ;
56890   int result;
56891
56892   {
56893     try {
56894       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56895     } catch (std::out_of_range& e) {
56896       {
56897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56898       };
56899     } catch (std::exception& e) {
56900       {
56901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (...) {
56904       {
56905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56906       };
56907     }
56908   }
56909   jresult = (int)result;
56910   return jresult;
56911 }
56912
56913
56914 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VISUAL_PROPERTY_SHADER_get() {
56915   int jresult ;
56916   int result;
56917
56918   {
56919     try {
56920       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56921     } catch (std::out_of_range& e) {
56922       {
56923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56924       };
56925     } catch (std::exception& e) {
56926       {
56927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56928       };
56929     } catch (...) {
56930       {
56931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56932       };
56933     }
56934   }
56935   jresult = (int)result;
56936   return jresult;
56937 }
56938
56939
56940 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VERTEX_SHADER_get() {
56941   int jresult ;
56942   int result;
56943
56944   {
56945     try {
56946       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (...) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56958       };
56959     }
56960   }
56961   jresult = (int)result;
56962   return jresult;
56963 }
56964
56965
56966 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FRAGMENT_SHADER_get() {
56967   int jresult ;
56968   int result;
56969
56970   {
56971     try {
56972       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56973     } catch (std::out_of_range& e) {
56974       {
56975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56976       };
56977     } catch (std::exception& e) {
56978       {
56979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56980       };
56981     } catch (...) {
56982       {
56983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56984       };
56985     }
56986   }
56987   jresult = (int)result;
56988   return jresult;
56989 }
56990
56991
56992 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SUBDIVIDE_GRID_X_get() {
56993   int jresult ;
56994   int result;
56995
56996   {
56997     try {
56998       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56999     } catch (std::out_of_range& e) {
57000       {
57001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57002       };
57003     } catch (std::exception& e) {
57004       {
57005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57006       };
57007     } catch (...) {
57008       {
57009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57010       };
57011     }
57012   }
57013   jresult = (int)result;
57014   return jresult;
57015 }
57016
57017
57018 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SUBDIVIDE_GRID_Y_get() {
57019   int jresult ;
57020   int result;
57021
57022   {
57023     try {
57024       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57025     } catch (std::out_of_range& e) {
57026       {
57027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57028       };
57029     } catch (std::exception& e) {
57030       {
57031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57032       };
57033     } catch (...) {
57034       {
57035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57036       };
57037     }
57038   }
57039   jresult = (int)result;
57040   return jresult;
57041 }
57042
57043
57044 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_HINTS_get() {
57045   int jresult ;
57046   int result;
57047
57048   {
57049     try {
57050       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57051     } catch (std::out_of_range& e) {
57052       {
57053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57054       };
57055     } catch (std::exception& e) {
57056       {
57057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57058       };
57059     } catch (...) {
57060       {
57061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57062       };
57063     }
57064   }
57065   jresult = (int)result;
57066   return jresult;
57067 }
57068
57069
57070 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_COLOR_get() {
57071   int jresult ;
57072   int result;
57073
57074   {
57075     try {
57076       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57077     } catch (std::out_of_range& e) {
57078       {
57079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57080       };
57081     } catch (std::exception& e) {
57082       {
57083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (...) {
57086       {
57087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57088       };
57089     }
57090   }
57091   jresult = (int)result;
57092   return jresult;
57093 }
57094
57095
57096 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SIZE_get() {
57097   int jresult ;
57098   int result;
57099
57100   {
57101     try {
57102       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57103     } catch (std::out_of_range& e) {
57104       {
57105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57106       };
57107     } catch (std::exception& e) {
57108       {
57109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57110       };
57111     } catch (...) {
57112       {
57113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57114       };
57115     }
57116   }
57117   jresult = (int)result;
57118   return jresult;
57119 }
57120
57121
57122 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ANTI_ALIASING_get() {
57123   int jresult ;
57124   int result;
57125
57126   {
57127     try {
57128       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57129     } catch (std::out_of_range& e) {
57130       {
57131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57132       };
57133     } catch (std::exception& e) {
57134       {
57135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57136       };
57137     } catch (...) {
57138       {
57139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57140       };
57141     }
57142   }
57143   jresult = (int)result;
57144   return jresult;
57145 }
57146
57147
57148 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MIX_COLOR_get() {
57149   int jresult ;
57150   int result;
57151
57152   {
57153     try {
57154       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57155     } catch (std::out_of_range& e) {
57156       {
57157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57158       };
57159     } catch (std::exception& e) {
57160       {
57161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57162       };
57163     } catch (...) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57166       };
57167     }
57168   }
57169   jresult = (int)result;
57170   return jresult;
57171 }
57172
57173
57174 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_START_POSITION_get() {
57175   int jresult ;
57176   int result;
57177
57178   {
57179     try {
57180       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57181     } catch (std::out_of_range& e) {
57182       {
57183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57184       };
57185     } catch (std::exception& e) {
57186       {
57187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57188       };
57189     } catch (...) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57192       };
57193     }
57194   }
57195   jresult = (int)result;
57196   return jresult;
57197 }
57198
57199
57200 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_END_POSITION_get() {
57201   int jresult ;
57202   int result;
57203
57204   {
57205     try {
57206       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57207     } catch (std::out_of_range& e) {
57208       {
57209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57210       };
57211     } catch (std::exception& e) {
57212       {
57213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57214       };
57215     } catch (...) {
57216       {
57217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57218       };
57219     }
57220   }
57221   jresult = (int)result;
57222   return jresult;
57223 }
57224
57225
57226 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_CENTER_get() {
57227   int jresult ;
57228   int result;
57229
57230   {
57231     try {
57232       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57233     } catch (std::out_of_range& e) {
57234       {
57235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57236       };
57237     } catch (std::exception& e) {
57238       {
57239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (...) {
57242       {
57243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57244       };
57245     }
57246   }
57247   jresult = (int)result;
57248   return jresult;
57249 }
57250
57251
57252 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RADIUS_get() {
57253   int jresult ;
57254   int result;
57255
57256   {
57257     try {
57258       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57259     } catch (std::out_of_range& e) {
57260       {
57261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57262       };
57263     } catch (std::exception& e) {
57264       {
57265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57266       };
57267     } catch (...) {
57268       {
57269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57270       };
57271     }
57272   }
57273   jresult = (int)result;
57274   return jresult;
57275 }
57276
57277
57278 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STOP_OFFSET_get() {
57279   int jresult ;
57280   int result;
57281
57282   {
57283     try {
57284       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (...) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57296       };
57297     }
57298   }
57299   jresult = (int)result;
57300   return jresult;
57301 }
57302
57303
57304 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STOP_COLOR_get() {
57305   int jresult ;
57306   int result;
57307
57308   {
57309     try {
57310       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57311     } catch (std::out_of_range& e) {
57312       {
57313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57314       };
57315     } catch (std::exception& e) {
57316       {
57317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (...) {
57320       {
57321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57322       };
57323     }
57324   }
57325   jresult = (int)result;
57326   return jresult;
57327 }
57328
57329
57330 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_UNITS_get() {
57331   int jresult ;
57332   int result;
57333
57334   {
57335     try {
57336       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57337     } catch (std::out_of_range& e) {
57338       {
57339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57340       };
57341     } catch (std::exception& e) {
57342       {
57343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57344       };
57345     } catch (...) {
57346       {
57347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57348       };
57349     }
57350   }
57351   jresult = (int)result;
57352   return jresult;
57353 }
57354
57355
57356 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SPREAD_METHOD_get() {
57357   int jresult ;
57358   int result;
57359
57360   {
57361     try {
57362       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57363     } catch (std::out_of_range& e) {
57364       {
57365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57366       };
57367     } catch (std::exception& e) {
57368       {
57369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57370       };
57371     } catch (...) {
57372       {
57373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57374       };
57375     }
57376   }
57377   jresult = (int)result;
57378   return jresult;
57379 }
57380
57381
57382 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_URL_get() {
57383   int jresult ;
57384   int result;
57385
57386   {
57387     try {
57388       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (...) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57400       };
57401     }
57402   }
57403   jresult = (int)result;
57404   return jresult;
57405 }
57406
57407
57408 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_FITTING_MODE_get() {
57409   int jresult ;
57410   int result;
57411
57412   {
57413     try {
57414       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57415     } catch (std::out_of_range& e) {
57416       {
57417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57418       };
57419     } catch (std::exception& e) {
57420       {
57421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57422       };
57423     } catch (...) {
57424       {
57425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57426       };
57427     }
57428   }
57429   jresult = (int)result;
57430   return jresult;
57431 }
57432
57433
57434 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_SAMPLING_MODE_get() {
57435   int jresult ;
57436   int result;
57437
57438   {
57439     try {
57440       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57441     } catch (std::out_of_range& e) {
57442       {
57443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57444       };
57445     } catch (std::exception& e) {
57446       {
57447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57448       };
57449     } catch (...) {
57450       {
57451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57452       };
57453     }
57454   }
57455   jresult = (int)result;
57456   return jresult;
57457 }
57458
57459
57460 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57461   int jresult ;
57462   int result;
57463
57464   {
57465     try {
57466       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57467     } catch (std::out_of_range& e) {
57468       {
57469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57470       };
57471     } catch (std::exception& e) {
57472       {
57473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57474       };
57475     } catch (...) {
57476       {
57477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57478       };
57479     }
57480   }
57481   jresult = (int)result;
57482   return jresult;
57483 }
57484
57485
57486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57487   int jresult ;
57488   int result;
57489
57490   {
57491     try {
57492       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57493     } catch (std::out_of_range& e) {
57494       {
57495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57496       };
57497     } catch (std::exception& e) {
57498       {
57499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57500       };
57501     } catch (...) {
57502       {
57503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57504       };
57505     }
57506   }
57507   jresult = (int)result;
57508   return jresult;
57509 }
57510
57511
57512 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57513   int jresult ;
57514   int result;
57515
57516   {
57517     try {
57518       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57519     } catch (std::out_of_range& e) {
57520       {
57521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57522       };
57523     } catch (std::exception& e) {
57524       {
57525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57526       };
57527     } catch (...) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57530       };
57531     }
57532   }
57533   jresult = (int)result;
57534   return jresult;
57535 }
57536
57537
57538 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_BORDER_ONLY_get() {
57539   int jresult ;
57540   int result;
57541
57542   {
57543     try {
57544       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57545     } catch (std::out_of_range& e) {
57546       {
57547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57548       };
57549     } catch (std::exception& e) {
57550       {
57551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57552       };
57553     } catch (...) {
57554       {
57555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57556       };
57557     }
57558   }
57559   jresult = (int)result;
57560   return jresult;
57561 }
57562
57563
57564 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_BATCHING_ENABLED_get() {
57565   int jresult ;
57566   int result;
57567
57568   {
57569     try {
57570       result = (int)Dali::Toolkit::ImageVisual::Property::BATCHING_ENABLED;
57571     } catch (std::out_of_range& e) {
57572       {
57573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57574       };
57575     } catch (std::exception& e) {
57576       {
57577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57578       };
57579     } catch (...) {
57580       {
57581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57582       };
57583     }
57584   }
57585   jresult = (int)result;
57586   return jresult;
57587 }
57588
57589
57590 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_PIXEL_AREA_get() {
57591   int jresult ;
57592   int result;
57593
57594   {
57595     try {
57596       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57597     } catch (std::out_of_range& e) {
57598       {
57599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57600       };
57601     } catch (std::exception& e) {
57602       {
57603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (...) {
57606       {
57607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57608       };
57609     }
57610   }
57611   jresult = (int)result;
57612   return jresult;
57613 }
57614
57615
57616 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_WRAP_MODE_U_get() {
57617   int jresult ;
57618   int result;
57619
57620   {
57621     try {
57622       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57623     } catch (std::out_of_range& e) {
57624       {
57625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57626       };
57627     } catch (std::exception& e) {
57628       {
57629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57630       };
57631     } catch (...) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57634       };
57635     }
57636   }
57637   jresult = (int)result;
57638   return jresult;
57639 }
57640
57641
57642 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_IMAGE_VISUAL_WRAP_MODE_V_get() {
57643   int jresult ;
57644   int result;
57645
57646   {
57647     try {
57648       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57649     } catch (std::out_of_range& e) {
57650       {
57651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57652       };
57653     } catch (std::exception& e) {
57654       {
57655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57656       };
57657     } catch (...) {
57658       {
57659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57660       };
57661     }
57662   }
57663   jresult = (int)result;
57664   return jresult;
57665 }
57666
57667
57668 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_OBJECT_URL_get() {
57669   int jresult ;
57670   int result;
57671
57672   {
57673     try {
57674       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57675     } catch (std::out_of_range& e) {
57676       {
57677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57678       };
57679     } catch (std::exception& e) {
57680       {
57681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57682       };
57683     } catch (...) {
57684       {
57685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57686       };
57687     }
57688   }
57689   jresult = (int)result;
57690   return jresult;
57691 }
57692
57693
57694 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MATERIAL_URL_get() {
57695   int jresult ;
57696   int result;
57697
57698   {
57699     try {
57700       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57701     } catch (std::out_of_range& e) {
57702       {
57703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57704       };
57705     } catch (std::exception& e) {
57706       {
57707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57708       };
57709     } catch (...) {
57710       {
57711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57712       };
57713     }
57714   }
57715   jresult = (int)result;
57716   return jresult;
57717 }
57718
57719
57720 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXTURES_PATH_get() {
57721   int jresult ;
57722   int result;
57723
57724   {
57725     try {
57726       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57727     } catch (std::out_of_range& e) {
57728       {
57729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57730       };
57731     } catch (std::exception& e) {
57732       {
57733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57738       };
57739     }
57740   }
57741   jresult = (int)result;
57742   return jresult;
57743 }
57744
57745
57746 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SHADING_MODE_get() {
57747   int jresult ;
57748   int result;
57749
57750   {
57751     try {
57752       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57753     } catch (std::out_of_range& e) {
57754       {
57755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57756       };
57757     } catch (std::exception& e) {
57758       {
57759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (...) {
57762       {
57763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57764       };
57765     }
57766   }
57767   jresult = (int)result;
57768   return jresult;
57769 }
57770
57771
57772 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_USE_MIPMAPPING_get() {
57773   int jresult ;
57774   int result;
57775
57776   {
57777     try {
57778       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57779     } catch (std::out_of_range& e) {
57780       {
57781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57782       };
57783     } catch (std::exception& e) {
57784       {
57785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (...) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57790       };
57791     }
57792   }
57793   jresult = (int)result;
57794   return jresult;
57795 }
57796
57797
57798 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_USE_SOFT_NORMALS_get() {
57799   int jresult ;
57800   int result;
57801
57802   {
57803     try {
57804       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57805     } catch (std::out_of_range& e) {
57806       {
57807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57808       };
57809     } catch (std::exception& e) {
57810       {
57811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57812       };
57813     } catch (...) {
57814       {
57815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57816       };
57817     }
57818   }
57819   jresult = (int)result;
57820   return jresult;
57821 }
57822
57823
57824 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_LIGHT_POSITION_get() {
57825   int jresult ;
57826   int result;
57827
57828   {
57829     try {
57830       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57831     } catch (std::out_of_range& e) {
57832       {
57833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57834       };
57835     } catch (std::exception& e) {
57836       {
57837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (...) {
57840       {
57841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57842       };
57843     }
57844   }
57845   jresult = (int)result;
57846   return jresult;
57847 }
57848
57849
57850 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SHAPE_get() {
57851   int jresult ;
57852   int result;
57853
57854   {
57855     try {
57856       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57857     } catch (std::out_of_range& e) {
57858       {
57859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57860       };
57861     } catch (std::exception& e) {
57862       {
57863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57864       };
57865     } catch (...) {
57866       {
57867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57868       };
57869     }
57870   }
57871   jresult = (int)result;
57872   return jresult;
57873 }
57874
57875
57876 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57877   int jresult ;
57878   int result;
57879
57880   {
57881     try {
57882       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57883     } catch (std::out_of_range& e) {
57884       {
57885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57886       };
57887     } catch (std::exception& e) {
57888       {
57889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57890       };
57891     } catch (...) {
57892       {
57893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57894       };
57895     }
57896   }
57897   jresult = (int)result;
57898   return jresult;
57899 }
57900
57901
57902 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SLICES_get() {
57903   int jresult ;
57904   int result;
57905
57906   {
57907     try {
57908       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (...) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57920       };
57921     }
57922   }
57923   jresult = (int)result;
57924   return jresult;
57925 }
57926
57927
57928 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_STACKS_get() {
57929   int jresult ;
57930   int result;
57931
57932   {
57933     try {
57934       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57935     } catch (std::out_of_range& e) {
57936       {
57937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57938       };
57939     } catch (std::exception& e) {
57940       {
57941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57942       };
57943     } catch (...) {
57944       {
57945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57946       };
57947     }
57948   }
57949   jresult = (int)result;
57950   return jresult;
57951 }
57952
57953
57954 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_TOP_RADIUS_get() {
57955   int jresult ;
57956   int result;
57957
57958   {
57959     try {
57960       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57961     } catch (std::out_of_range& e) {
57962       {
57963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57964       };
57965     } catch (std::exception& e) {
57966       {
57967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57968       };
57969     } catch (...) {
57970       {
57971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57972       };
57973     }
57974   }
57975   jresult = (int)result;
57976   return jresult;
57977 }
57978
57979
57980 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_BOTTOM_RADIUS_get() {
57981   int jresult ;
57982   int result;
57983
57984   {
57985     try {
57986       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57987     } catch (std::out_of_range& e) {
57988       {
57989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57990       };
57991     } catch (std::exception& e) {
57992       {
57993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57994       };
57995     } catch (...) {
57996       {
57997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57998       };
57999     }
58000   }
58001   jresult = (int)result;
58002   return jresult;
58003 }
58004
58005
58006 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_HEIGHT_get() {
58007   int jresult ;
58008   int result;
58009
58010   {
58011     try {
58012       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58013     } catch (std::out_of_range& e) {
58014       {
58015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58016       };
58017     } catch (std::exception& e) {
58018       {
58019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58020       };
58021     } catch (...) {
58022       {
58023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58024       };
58025     }
58026   }
58027   jresult = (int)result;
58028   return jresult;
58029 }
58030
58031
58032 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_RADIUS_get() {
58033   int jresult ;
58034   int result;
58035
58036   {
58037     try {
58038       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58039     } catch (std::out_of_range& e) {
58040       {
58041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58042       };
58043     } catch (std::exception& e) {
58044       {
58045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (...) {
58048       {
58049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58050       };
58051     }
58052   }
58053   jresult = (int)result;
58054   return jresult;
58055 }
58056
58057
58058 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_SCALE_DIMENSIONS_get() {
58059   int jresult ;
58060   int result;
58061
58062   {
58063     try {
58064       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58065     } catch (std::out_of_range& e) {
58066       {
58067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58068       };
58069     } catch (std::exception& e) {
58070       {
58071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58072       };
58073     } catch (...) {
58074       {
58075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58076       };
58077     }
58078   }
58079   jresult = (int)result;
58080   return jresult;
58081 }
58082
58083
58084 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BEVEL_PERCENTAGE_get() {
58085   int jresult ;
58086   int result;
58087
58088   {
58089     try {
58090       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58091     } catch (std::out_of_range& e) {
58092       {
58093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (std::exception& e) {
58096       {
58097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (...) {
58100       {
58101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58102       };
58103     }
58104   }
58105   jresult = (int)result;
58106   return jresult;
58107 }
58108
58109
58110 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_BEVEL_SMOOTHNESS_get() {
58111   int jresult ;
58112   int result;
58113
58114   {
58115     try {
58116       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58117     } catch (std::out_of_range& e) {
58118       {
58119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58120       };
58121     } catch (std::exception& e) {
58122       {
58123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58124       };
58125     } catch (...) {
58126       {
58127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58128       };
58129     }
58130   }
58131   jresult = (int)result;
58132   return jresult;
58133 }
58134
58135
58136 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58137   int jresult ;
58138   int result;
58139
58140   {
58141     try {
58142       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58143     } catch (std::out_of_range& e) {
58144       {
58145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58146       };
58147     } catch (std::exception& e) {
58148       {
58149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58150       };
58151     } catch (...) {
58152       {
58153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58154       };
58155     }
58156   }
58157   jresult = (int)result;
58158   return jresult;
58159 }
58160
58161 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXT_get() {
58162   int jresult ;
58163   int result;
58164
58165   {
58166     try {
58167       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58168     } catch (std::out_of_range& e) {
58169       {
58170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58171       };
58172     } catch (std::exception& e) {
58173       {
58174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58175       };
58176     } catch (...) {
58177       {
58178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58179       };
58180     }
58181   }
58182   jresult = (int)result;
58183   return jresult;
58184 }
58185
58186
58187 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FONT_FAMILY_get() {
58188   int jresult ;
58189   int result;
58190
58191   {
58192     try {
58193       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58194     } catch (std::out_of_range& e) {
58195       {
58196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58197       };
58198     } catch (std::exception& e) {
58199       {
58200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58201       };
58202     } catch (...) {
58203       {
58204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58205       };
58206     }
58207   }
58208   jresult = (int)result;
58209   return jresult;
58210 }
58211
58212
58213 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FONT_STYLE_get() {
58214   int jresult ;
58215   int result;
58216
58217   {
58218     try {
58219       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58220     } catch (std::out_of_range& e) {
58221       {
58222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58223       };
58224     } catch (std::exception& e) {
58225       {
58226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58227       };
58228     } catch (...) {
58229       {
58230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58231       };
58232     }
58233   }
58234   jresult = (int)result;
58235   return jresult;
58236 }
58237
58238
58239 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_POINT_SIZE_get() {
58240   int jresult ;
58241   int result;
58242
58243   {
58244     try {
58245       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58246     } catch (std::out_of_range& e) {
58247       {
58248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58249       };
58250     } catch (std::exception& e) {
58251       {
58252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58253       };
58254     } catch (...) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58257       };
58258     }
58259   }
58260   jresult = (int)result;
58261   return jresult;
58262 }
58263
58264
58265 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_MULTI_LINE_get() {
58266   int jresult ;
58267   int result;
58268
58269   {
58270     try {
58271       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58272     } catch (std::out_of_range& e) {
58273       {
58274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58275       };
58276     } catch (std::exception& e) {
58277       {
58278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58279       };
58280     } catch (...) {
58281       {
58282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58283       };
58284     }
58285   }
58286   jresult = (int)result;
58287   return jresult;
58288 }
58289
58290
58291 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_HORIZONTAL_ALIGNMENT_get() {
58292   int jresult ;
58293   int result;
58294
58295   {
58296     try {
58297       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58298     } catch (std::out_of_range& e) {
58299       {
58300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58301       };
58302     } catch (std::exception& e) {
58303       {
58304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58305       };
58306     } catch (...) {
58307       {
58308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58309       };
58310     }
58311   }
58312   jresult = (int)result;
58313   return jresult;
58314 }
58315
58316
58317 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VERTICAL_ALIGNMENT_get() {
58318   int jresult ;
58319   int result;
58320
58321   {
58322     try {
58323       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58324     } catch (std::out_of_range& e) {
58325       {
58326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58327       };
58328     } catch (std::exception& e) {
58329       {
58330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58331       };
58332     } catch (...) {
58333       {
58334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58335       };
58336     }
58337   }
58338   jresult = (int)result;
58339   return jresult;
58340 }
58341
58342
58343 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TEXT_COLOR_get() {
58344   int jresult ;
58345   int result;
58346
58347   {
58348     try {
58349       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58350     } catch (std::out_of_range& e) {
58351       {
58352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58353       };
58354     } catch (std::exception& e) {
58355       {
58356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58357       };
58358     } catch (...) {
58359       {
58360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58361       };
58362     }
58363   }
58364   jresult = (int)result;
58365   return jresult;
58366 }
58367
58368
58369 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ENABLE_MARKUP_get() {
58370   int jresult ;
58371   int result;
58372
58373   {
58374     try {
58375       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58376     } catch (std::out_of_range& e) {
58377       {
58378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58379       };
58380     } catch (std::exception& e) {
58381       {
58382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58383       };
58384     } catch (...) {
58385       {
58386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58387       };
58388     }
58389   }
58390   jresult = (int)result;
58391   return jresult;
58392 }
58393
58394
58395 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Builder() {
58396   void * jresult ;
58397   Dali::Toolkit::Builder *result = 0 ;
58398
58399   {
58400     try {
58401       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58402     } catch (std::out_of_range& e) {
58403       {
58404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58405       };
58406     } catch (std::exception& e) {
58407       {
58408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58409       };
58410     } catch (...) {
58411       {
58412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58413       };
58414     }
58415   }
58416   jresult = (void *)result;
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_New() {
58422   void * jresult ;
58423   Dali::Toolkit::Builder result;
58424
58425   {
58426     try {
58427       result = Dali::Toolkit::Builder::New();
58428     } catch (std::out_of_range& e) {
58429       {
58430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58431       };
58432     } catch (std::exception& e) {
58433       {
58434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58435       };
58436     } catch (...) {
58437       {
58438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58439       };
58440     }
58441   }
58442   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58443   return jresult;
58444 }
58445
58446
58447 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Builder(void * jarg1) {
58448   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58449
58450   arg1 = (Dali::Toolkit::Builder *)jarg1;
58451   {
58452     try {
58453       delete arg1;
58454     } catch (std::out_of_range& e) {
58455       {
58456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58457       };
58458     } catch (std::exception& e) {
58459       {
58460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58461       };
58462     } catch (...) {
58463       {
58464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58465       };
58466     }
58467   }
58468 }
58469
58470
58471 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58472   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58473   std::string *arg2 = 0 ;
58474   Dali::Toolkit::Builder::UIFormat arg3 ;
58475
58476   arg1 = (Dali::Toolkit::Builder *)jarg1;
58477   if (!jarg2) {
58478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58479     return ;
58480   }
58481   std::string arg2_str(jarg2);
58482   arg2 = &arg2_str;
58483   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58484   {
58485     try {
58486       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58487     } catch (std::out_of_range& e) {
58488       {
58489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58490       };
58491     } catch (std::exception& e) {
58492       {
58493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58494       };
58495     } catch (...) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58498       };
58499     }
58500   }
58501
58502   //argout typemap for const std::string&
58503
58504 }
58505
58506
58507 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58508   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58509   std::string *arg2 = 0 ;
58510
58511   arg1 = (Dali::Toolkit::Builder *)jarg1;
58512   if (!jarg2) {
58513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58514     return ;
58515   }
58516   std::string arg2_str(jarg2);
58517   arg2 = &arg2_str;
58518   {
58519     try {
58520       (arg1)->LoadFromString((std::string const &)*arg2);
58521     } catch (std::out_of_range& e) {
58522       {
58523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58524       };
58525     } catch (std::exception& e) {
58526       {
58527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58528       };
58529     } catch (...) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58532       };
58533     }
58534   }
58535
58536   //argout typemap for const std::string&
58537
58538 }
58539
58540
58541 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddConstants(void * jarg1, void * jarg2) {
58542   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58543   Dali::Property::Map *arg2 = 0 ;
58544
58545   arg1 = (Dali::Toolkit::Builder *)jarg1;
58546   arg2 = (Dali::Property::Map *)jarg2;
58547   if (!arg2) {
58548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58549     return ;
58550   }
58551   {
58552     try {
58553       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58554     } catch (std::out_of_range& e) {
58555       {
58556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58557       };
58558     } catch (std::exception& e) {
58559       {
58560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58561       };
58562     } catch (...) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58565       };
58566     }
58567   }
58568 }
58569
58570
58571 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58572   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58573   std::string *arg2 = 0 ;
58574   Dali::Property::Value *arg3 = 0 ;
58575
58576   arg1 = (Dali::Toolkit::Builder *)jarg1;
58577   if (!jarg2) {
58578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58579     return ;
58580   }
58581   std::string arg2_str(jarg2);
58582   arg2 = &arg2_str;
58583   arg3 = (Dali::Property::Value *)jarg3;
58584   if (!arg3) {
58585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58586     return ;
58587   }
58588   {
58589     try {
58590       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58591     } catch (std::out_of_range& e) {
58592       {
58593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58594       };
58595     } catch (std::exception& e) {
58596       {
58597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58598       };
58599     } catch (...) {
58600       {
58601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58602       };
58603     }
58604   }
58605
58606   //argout typemap for const std::string&
58607
58608 }
58609
58610
58611 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetConstants(void * jarg1) {
58612   void * jresult ;
58613   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58614   Dali::Property::Map *result = 0 ;
58615
58616   arg1 = (Dali::Toolkit::Builder *)jarg1;
58617   {
58618     try {
58619       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58620     } catch (std::out_of_range& e) {
58621       {
58622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58623       };
58624     } catch (std::exception& e) {
58625       {
58626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (...) {
58629       {
58630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58631       };
58632     }
58633   }
58634   jresult = (void *)result;
58635   return jresult;
58636 }
58637
58638
58639 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetConstant(void * jarg1, char * jarg2) {
58640   void * jresult ;
58641   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58642   std::string *arg2 = 0 ;
58643   Dali::Property::Value *result = 0 ;
58644
58645   arg1 = (Dali::Toolkit::Builder *)jarg1;
58646   if (!jarg2) {
58647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58648     return 0;
58649   }
58650   std::string arg2_str(jarg2);
58651   arg2 = &arg2_str;
58652   {
58653     try {
58654       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58655     } catch (std::out_of_range& e) {
58656       {
58657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (std::exception& e) {
58660       {
58661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (...) {
58664       {
58665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58666       };
58667     }
58668   }
58669   jresult = (void *)result;
58670
58671   //argout typemap for const std::string&
58672
58673   return jresult;
58674 }
58675
58676
58677 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58678   void * jresult ;
58679   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58680   std::string *arg2 = 0 ;
58681   Dali::Animation result;
58682
58683   arg1 = (Dali::Toolkit::Builder *)jarg1;
58684   if (!jarg2) {
58685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58686     return 0;
58687   }
58688   std::string arg2_str(jarg2);
58689   arg2 = &arg2_str;
58690   {
58691     try {
58692       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58693     } catch (std::out_of_range& e) {
58694       {
58695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58696       };
58697     } catch (std::exception& e) {
58698       {
58699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58700       };
58701     } catch (...) {
58702       {
58703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58704       };
58705     }
58706   }
58707   jresult = new Dali::Animation((const Dali::Animation &)result);
58708
58709   //argout typemap for const std::string&
58710
58711   return jresult;
58712 }
58713
58714
58715 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58716   void * jresult ;
58717   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58718   std::string *arg2 = 0 ;
58719   Dali::Property::Map *arg3 = 0 ;
58720   Dali::Animation result;
58721
58722   arg1 = (Dali::Toolkit::Builder *)jarg1;
58723   if (!jarg2) {
58724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58725     return 0;
58726   }
58727   std::string arg2_str(jarg2);
58728   arg2 = &arg2_str;
58729   arg3 = (Dali::Property::Map *)jarg3;
58730   if (!arg3) {
58731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58732     return 0;
58733   }
58734   {
58735     try {
58736       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58737     } catch (std::out_of_range& e) {
58738       {
58739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58740       };
58741     } catch (std::exception& e) {
58742       {
58743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58744       };
58745     } catch (...) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58748       };
58749     }
58750   }
58751   jresult = new Dali::Animation((const Dali::Animation &)result);
58752
58753   //argout typemap for const std::string&
58754
58755   return jresult;
58756 }
58757
58758
58759 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58760   void * jresult ;
58761   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58762   std::string *arg2 = 0 ;
58763   Dali::Actor arg3 ;
58764   Dali::Actor *argp3 ;
58765   Dali::Animation result;
58766
58767   arg1 = (Dali::Toolkit::Builder *)jarg1;
58768   if (!jarg2) {
58769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58770     return 0;
58771   }
58772   std::string arg2_str(jarg2);
58773   arg2 = &arg2_str;
58774   argp3 = (Dali::Actor *)jarg3;
58775   if (!argp3) {
58776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58777     return 0;
58778   }
58779   arg3 = *argp3;
58780   {
58781     try {
58782       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58783     } catch (std::out_of_range& e) {
58784       {
58785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58786       };
58787     } catch (std::exception& e) {
58788       {
58789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58790       };
58791     } catch (...) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58794       };
58795     }
58796   }
58797   jresult = new Dali::Animation((const Dali::Animation &)result);
58798
58799   //argout typemap for const std::string&
58800
58801   return jresult;
58802 }
58803
58804
58805 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58806   void * jresult ;
58807   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58808   std::string *arg2 = 0 ;
58809   Dali::Property::Map *arg3 = 0 ;
58810   Dali::Actor arg4 ;
58811   Dali::Actor *argp4 ;
58812   Dali::Animation result;
58813
58814   arg1 = (Dali::Toolkit::Builder *)jarg1;
58815   if (!jarg2) {
58816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58817     return 0;
58818   }
58819   std::string arg2_str(jarg2);
58820   arg2 = &arg2_str;
58821   arg3 = (Dali::Property::Map *)jarg3;
58822   if (!arg3) {
58823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58824     return 0;
58825   }
58826   argp4 = (Dali::Actor *)jarg4;
58827   if (!argp4) {
58828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58829     return 0;
58830   }
58831   arg4 = *argp4;
58832   {
58833     try {
58834       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58835     } catch (std::out_of_range& e) {
58836       {
58837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58838       };
58839     } catch (std::exception& e) {
58840       {
58841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58842       };
58843     } catch (...) {
58844       {
58845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58846       };
58847     }
58848   }
58849   jresult = new Dali::Animation((const Dali::Animation &)result);
58850
58851   //argout typemap for const std::string&
58852
58853   return jresult;
58854 }
58855
58856
58857 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58858   void * jresult ;
58859   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58860   std::string *arg2 = 0 ;
58861   Dali::BaseHandle result;
58862
58863   arg1 = (Dali::Toolkit::Builder *)jarg1;
58864   if (!jarg2) {
58865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58866     return 0;
58867   }
58868   std::string arg2_str(jarg2);
58869   arg2 = &arg2_str;
58870   {
58871     try {
58872       result = (arg1)->Create((std::string const &)*arg2);
58873     } catch (std::out_of_range& e) {
58874       {
58875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (std::exception& e) {
58878       {
58879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58888
58889   //argout typemap for const std::string&
58890
58891   return jresult;
58892 }
58893
58894
58895 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58896   void * jresult ;
58897   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58898   std::string *arg2 = 0 ;
58899   Dali::Property::Map *arg3 = 0 ;
58900   Dali::BaseHandle result;
58901
58902   arg1 = (Dali::Toolkit::Builder *)jarg1;
58903   if (!jarg2) {
58904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58905     return 0;
58906   }
58907   std::string arg2_str(jarg2);
58908   arg2 = &arg2_str;
58909   arg3 = (Dali::Property::Map *)jarg3;
58910   if (!arg3) {
58911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58912     return 0;
58913   }
58914   {
58915     try {
58916       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58917     } catch (std::out_of_range& e) {
58918       {
58919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (std::exception& e) {
58922       {
58923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (...) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58928       };
58929     }
58930   }
58931   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58932
58933   //argout typemap for const std::string&
58934
58935   return jresult;
58936 }
58937
58938
58939 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58940   void * jresult ;
58941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58942   std::string *arg2 = 0 ;
58943   Dali::BaseHandle result;
58944
58945   arg1 = (Dali::Toolkit::Builder *)jarg1;
58946   if (!jarg2) {
58947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58948     return 0;
58949   }
58950   std::string arg2_str(jarg2);
58951   arg2 = &arg2_str;
58952   {
58953     try {
58954       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58955     } catch (std::out_of_range& e) {
58956       {
58957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (std::exception& e) {
58960       {
58961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (...) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58966       };
58967     }
58968   }
58969   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58970
58971   //argout typemap for const std::string&
58972
58973   return jresult;
58974 }
58975
58976
58977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58978   unsigned int jresult ;
58979   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58980   std::string *arg2 = 0 ;
58981   Dali::Handle *arg3 = 0 ;
58982   bool result;
58983
58984   arg1 = (Dali::Toolkit::Builder *)jarg1;
58985   if (!jarg2) {
58986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58987     return 0;
58988   }
58989   std::string arg2_str(jarg2);
58990   arg2 = &arg2_str;
58991   arg3 = (Dali::Handle *)jarg3;
58992   if (!arg3) {
58993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58994     return 0;
58995   }
58996   {
58997     try {
58998       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58999     } catch (std::out_of_range& e) {
59000       {
59001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59002       };
59003     } catch (std::exception& e) {
59004       {
59005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59006       };
59007     } catch (...) {
59008       {
59009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59010       };
59011     }
59012   }
59013   jresult = result;
59014
59015   //argout typemap for const std::string&
59016
59017   return jresult;
59018 }
59019
59020
59021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59022   unsigned int jresult ;
59023   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59024   Dali::Handle *arg2 = 0 ;
59025   std::string *arg3 = 0 ;
59026   bool result;
59027
59028   arg1 = (Dali::Toolkit::Builder *)jarg1;
59029   arg2 = (Dali::Handle *)jarg2;
59030   if (!arg2) {
59031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59032     return 0;
59033   }
59034   if (!jarg3) {
59035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59036     return 0;
59037   }
59038   std::string arg3_str(jarg3);
59039   arg3 = &arg3_str;
59040   {
59041     try {
59042       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59043     } catch (std::out_of_range& e) {
59044       {
59045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59046       };
59047     } catch (std::exception& e) {
59048       {
59049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59050       };
59051     } catch (...) {
59052       {
59053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59054       };
59055     }
59056   }
59057   jresult = result;
59058
59059   //argout typemap for const std::string&
59060
59061   return jresult;
59062 }
59063
59064
59065 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59066   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59067   Dali::Actor arg2 ;
59068   Dali::Actor *argp2 ;
59069
59070   arg1 = (Dali::Toolkit::Builder *)jarg1;
59071   argp2 = (Dali::Actor *)jarg2;
59072   if (!argp2) {
59073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59074     return ;
59075   }
59076   arg2 = *argp2;
59077   {
59078     try {
59079       (arg1)->AddActors(arg2);
59080     } catch (std::out_of_range& e) {
59081       {
59082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59083       };
59084     } catch (std::exception& e) {
59085       {
59086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59087       };
59088     } catch (...) {
59089       {
59090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59091       };
59092     }
59093   }
59094 }
59095
59096
59097 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59098   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59099   std::string *arg2 = 0 ;
59100   Dali::Actor arg3 ;
59101   Dali::Actor *argp3 ;
59102
59103   arg1 = (Dali::Toolkit::Builder *)jarg1;
59104   if (!jarg2) {
59105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59106     return ;
59107   }
59108   std::string arg2_str(jarg2);
59109   arg2 = &arg2_str;
59110   argp3 = (Dali::Actor *)jarg3;
59111   if (!argp3) {
59112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59113     return ;
59114   }
59115   arg3 = *argp3;
59116   {
59117     try {
59118       (arg1)->AddActors((std::string const &)*arg2,arg3);
59119     } catch (std::out_of_range& e) {
59120       {
59121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59122       };
59123     } catch (std::exception& e) {
59124       {
59125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59126       };
59127     } catch (...) {
59128       {
59129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59130       };
59131     }
59132   }
59133
59134   //argout typemap for const std::string&
59135
59136 }
59137
59138
59139 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59140   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59141   std::string *arg2 = 0 ;
59142
59143   arg1 = (Dali::Toolkit::Builder *)jarg1;
59144   if (!jarg2) {
59145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59146     return ;
59147   }
59148   std::string arg2_str(jarg2);
59149   arg2 = &arg2_str;
59150   {
59151     try {
59152       (arg1)->CreateRenderTask((std::string const &)*arg2);
59153     } catch (std::out_of_range& e) {
59154       {
59155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59156       };
59157     } catch (std::exception& e) {
59158       {
59159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59160       };
59161     } catch (...) {
59162       {
59163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59164       };
59165     }
59166   }
59167
59168   //argout typemap for const std::string&
59169
59170 }
59171
59172
59173 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59174   void * jresult ;
59175   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59176   std::string *arg2 = 0 ;
59177   Dali::FrameBufferImage result;
59178
59179   arg1 = (Dali::Toolkit::Builder *)jarg1;
59180   if (!jarg2) {
59181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59182     return 0;
59183   }
59184   std::string arg2_str(jarg2);
59185   arg2 = &arg2_str;
59186   {
59187     try {
59188       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59189     } catch (std::out_of_range& e) {
59190       {
59191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59192       };
59193     } catch (std::exception& e) {
59194       {
59195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (...) {
59198       {
59199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59200       };
59201     }
59202   }
59203   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59204
59205   //argout typemap for const std::string&
59206
59207   return jresult;
59208 }
59209
59210
59211 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetPath(void * jarg1, char * jarg2) {
59212   void * jresult ;
59213   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59214   std::string *arg2 = 0 ;
59215   Dali::Path result;
59216
59217   arg1 = (Dali::Toolkit::Builder *)jarg1;
59218   if (!jarg2) {
59219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59220     return 0;
59221   }
59222   std::string arg2_str(jarg2);
59223   arg2 = &arg2_str;
59224   {
59225     try {
59226       result = (arg1)->GetPath((std::string const &)*arg2);
59227     } catch (std::out_of_range& e) {
59228       {
59229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59230       };
59231     } catch (std::exception& e) {
59232       {
59233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59234       };
59235     } catch (...) {
59236       {
59237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59238       };
59239     }
59240   }
59241   jresult = new Dali::Path((const Dali::Path &)result);
59242
59243   //argout typemap for const std::string&
59244
59245   return jresult;
59246 }
59247
59248
59249 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59250   void * jresult ;
59251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59252   std::string *arg2 = 0 ;
59253   Dali::PathConstrainer result;
59254
59255   arg1 = (Dali::Toolkit::Builder *)jarg1;
59256   if (!jarg2) {
59257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59258     return 0;
59259   }
59260   std::string arg2_str(jarg2);
59261   arg2 = &arg2_str;
59262   {
59263     try {
59264       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59265     } catch (std::out_of_range& e) {
59266       {
59267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (std::exception& e) {
59270       {
59271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59272       };
59273     } catch (...) {
59274       {
59275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59276       };
59277     }
59278   }
59279   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59280
59281   //argout typemap for const std::string&
59282
59283   return jresult;
59284 }
59285
59286
59287 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59288   void * jresult ;
59289   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59290   std::string *arg2 = 0 ;
59291   Dali::LinearConstrainer result;
59292
59293   arg1 = (Dali::Toolkit::Builder *)jarg1;
59294   if (!jarg2) {
59295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59296     return 0;
59297   }
59298   std::string arg2_str(jarg2);
59299   arg2 = &arg2_str;
59300   {
59301     try {
59302       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59303     } catch (std::out_of_range& e) {
59304       {
59305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59306       };
59307     } catch (std::exception& e) {
59308       {
59309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59310       };
59311     } catch (...) {
59312       {
59313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59314       };
59315     }
59316   }
59317   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59318
59319   //argout typemap for const std::string&
59320
59321   return jresult;
59322 }
59323
59324
59325 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Builder_QuitSignal(void * jarg1) {
59326   void * jresult ;
59327   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59328   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59329
59330   arg1 = (Dali::Toolkit::Builder *)jarg1;
59331   {
59332     try {
59333       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59334     } catch (std::out_of_range& e) {
59335       {
59336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59337       };
59338     } catch (std::exception& e) {
59339       {
59340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59341       };
59342     } catch (...) {
59343       {
59344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59345       };
59346     }
59347   }
59348   jresult = (void *)result;
59349   return jresult;
59350 }
59351
59352
59353 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_0() {
59354   void * jresult ;
59355   Dali::Toolkit::TransitionData *result = 0 ;
59356
59357   {
59358     try {
59359       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59360     } catch (std::out_of_range& e) {
59361       {
59362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59363       };
59364     } catch (std::exception& e) {
59365       {
59366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59367       };
59368     } catch (...) {
59369       {
59370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59371       };
59372     }
59373   }
59374   jresult = (void *)result;
59375   return jresult;
59376 }
59377
59378
59379 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TransitionData(void * jarg1) {
59380   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59381
59382   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59383   {
59384     try {
59385       delete arg1;
59386     } catch (std::out_of_range& e) {
59387       {
59388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59389       };
59390     } catch (std::exception& e) {
59391       {
59392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59393       };
59394     } catch (...) {
59395       {
59396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59397       };
59398     }
59399   }
59400 }
59401
59402
59403 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_New__SWIG_0(void * jarg1) {
59404   void * jresult ;
59405   Dali::Property::Map *arg1 = 0 ;
59406   Dali::Toolkit::TransitionData result;
59407
59408   arg1 = (Dali::Property::Map *)jarg1;
59409   if (!arg1) {
59410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59411     return 0;
59412   }
59413   {
59414     try {
59415       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59416     } catch (std::out_of_range& e) {
59417       {
59418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59419       };
59420     } catch (std::exception& e) {
59421       {
59422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59423       };
59424     } catch (...) {
59425       {
59426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59427       };
59428     }
59429   }
59430   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59431   return jresult;
59432 }
59433
59434
59435 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_New__SWIG_1(void * jarg1) {
59436   void * jresult ;
59437   Dali::Property::Array *arg1 = 0 ;
59438   Dali::Toolkit::TransitionData result;
59439
59440   arg1 = (Dali::Property::Array *)jarg1;
59441   if (!arg1) {
59442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59443     return 0;
59444   }
59445   {
59446     try {
59447       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59448     } catch (std::out_of_range& e) {
59449       {
59450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59451       };
59452     } catch (std::exception& e) {
59453       {
59454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (...) {
59457       {
59458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59459       };
59460     }
59461   }
59462   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59463   return jresult;
59464 }
59465
59466
59467 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_DownCast(void * jarg1) {
59468   void * jresult ;
59469   Dali::BaseHandle arg1 ;
59470   Dali::BaseHandle *argp1 ;
59471   Dali::Toolkit::TransitionData result;
59472
59473   argp1 = (Dali::BaseHandle *)jarg1;
59474   if (!argp1) {
59475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59476     return 0;
59477   }
59478   arg1 = *argp1;
59479   {
59480     try {
59481       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59482     } catch (std::out_of_range& e) {
59483       {
59484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59485       };
59486     } catch (std::exception& e) {
59487       {
59488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59489       };
59490     } catch (...) {
59491       {
59492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59493       };
59494     }
59495   }
59496   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59497   return jresult;
59498 }
59499
59500
59501 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_1(void * jarg1) {
59502   void * jresult ;
59503   Dali::Toolkit::TransitionData *arg1 = 0 ;
59504   Dali::Toolkit::TransitionData *result = 0 ;
59505
59506   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59507   if (!arg1) {
59508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59509     return 0;
59510   }
59511   {
59512     try {
59513       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59514     } catch (std::out_of_range& e) {
59515       {
59516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59517       };
59518     } catch (std::exception& e) {
59519       {
59520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59521       };
59522     } catch (...) {
59523       {
59524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59525       };
59526     }
59527   }
59528   jresult = (void *)result;
59529   return jresult;
59530 }
59531
59532
59533 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_Assign(void * jarg1, void * jarg2) {
59534   void * jresult ;
59535   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59536   Dali::Toolkit::TransitionData *arg2 = 0 ;
59537   Dali::Toolkit::TransitionData *result = 0 ;
59538
59539   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59540   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59541   if (!arg2) {
59542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59543     return 0;
59544   }
59545   {
59546     try {
59547       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59548     } catch (std::out_of_range& e) {
59549       {
59550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59551       };
59552     } catch (std::exception& e) {
59553       {
59554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59555       };
59556     } catch (...) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59559       };
59560     }
59561   }
59562   jresult = (void *)result;
59563   return jresult;
59564 }
59565
59566
59567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TransitionData_Count(void * jarg1) {
59568   unsigned long jresult ;
59569   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59570   size_t result;
59571
59572   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59573   {
59574     try {
59575       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59587       };
59588     }
59589   }
59590   jresult = (unsigned long)result;
59591   return jresult;
59592 }
59593
59594
59595 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59596   void * jresult ;
59597   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59598   size_t arg2 ;
59599   Dali::Property::Map result;
59600
59601   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59602   arg2 = (size_t)jarg2;
59603   {
59604     try {
59605       result = (arg1)->GetAnimatorAt(arg2);
59606     } catch (std::out_of_range& e) {
59607       {
59608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59609       };
59610     } catch (std::exception& e) {
59611       {
59612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59613       };
59614     } catch (...) {
59615       {
59616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59617       };
59618     }
59619   }
59620   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59621   return jresult;
59622 }
59623
59624
59625 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TransitionData__SWIG_2(void * jarg1) {
59626   void * jresult ;
59627   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59628   Dali::Toolkit::TransitionData *result = 0 ;
59629
59630   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59631   {
59632     try {
59633       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59634     } catch (std::out_of_range& e) {
59635       {
59636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (std::exception& e) {
59639       {
59640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (...) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59645       };
59646     }
59647   }
59648   jresult = (void *)result;
59649   return jresult;
59650 }
59651
59652
59653 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_New() {
59654   void * jresult ;
59655   Dali::Toolkit::Control result;
59656
59657   {
59658     try {
59659       result = Dali::Toolkit::Internal::Control::New();
59660     } catch (std::out_of_range& e) {
59661       {
59662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (std::exception& e) {
59665       {
59666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (...) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59671       };
59672     }
59673   }
59674   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59675   return jresult;
59676 }
59677
59678
59679 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59681   std::string *arg2 = 0 ;
59682
59683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59684   if (!jarg2) {
59685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59686     return ;
59687   }
59688   std::string arg2_str(jarg2);
59689   arg2 = &arg2_str;
59690   {
59691     try {
59692       (arg1)->SetStyleName((std::string const &)*arg2);
59693     } catch (std::out_of_range& e) {
59694       {
59695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59696       };
59697     } catch (std::exception& e) {
59698       {
59699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59700       };
59701     } catch (...) {
59702       {
59703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59704       };
59705     }
59706   }
59707
59708   //argout typemap for const std::string&
59709
59710 }
59711
59712
59713 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_ViewImpl_GetStyleName(void * jarg1) {
59714   char * jresult ;
59715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59716   std::string *result = 0 ;
59717
59718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59719   {
59720     try {
59721       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59722     } catch (std::out_of_range& e) {
59723       {
59724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59725       };
59726     } catch (std::exception& e) {
59727       {
59728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (...) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59733       };
59734     }
59735   }
59736   jresult = SWIG_csharp_string_callback(result->c_str());
59737   return jresult;
59738 }
59739
59740
59741 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59743   Dali::Vector4 *arg2 = 0 ;
59744
59745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59746   arg2 = (Dali::Vector4 *)jarg2;
59747   if (!arg2) {
59748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59749     return ;
59750   }
59751   {
59752     try {
59753       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59754     } catch (std::out_of_range& e) {
59755       {
59756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59757       };
59758     } catch (std::exception& e) {
59759       {
59760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59761       };
59762     } catch (...) {
59763       {
59764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59765       };
59766     }
59767   }
59768 }
59769
59770
59771 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetBackgroundColor(void * jarg1) {
59772   void * jresult ;
59773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59774   Dali::Vector4 result;
59775
59776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59777   {
59778     try {
59779       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59780     } catch (std::out_of_range& e) {
59781       {
59782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59783       };
59784     } catch (std::exception& e) {
59785       {
59786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59787       };
59788     } catch (...) {
59789       {
59790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59791       };
59792     }
59793   }
59794   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59795   return jresult;
59796 }
59797
59798
59799 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59801   Dali::Image arg2 ;
59802   Dali::Image *argp2 ;
59803
59804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59805   argp2 = (Dali::Image *)jarg2;
59806   if (!argp2) {
59807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59808     return ;
59809   }
59810   arg2 = *argp2;
59811   {
59812     try {
59813       (arg1)->SetBackgroundImage(arg2);
59814     } catch (std::out_of_range& e) {
59815       {
59816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59817       };
59818     } catch (std::exception& e) {
59819       {
59820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59821       };
59822     } catch (...) {
59823       {
59824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59825       };
59826     }
59827   }
59828 }
59829
59830
59831 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59833   Dali::Property::Map *arg2 = 0 ;
59834
59835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59836   arg2 = (Dali::Property::Map *)jarg2;
59837   if (!arg2) {
59838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59839     return ;
59840   }
59841   {
59842     try {
59843       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59844     } catch (std::out_of_range& e) {
59845       {
59846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59847       };
59848     } catch (std::exception& e) {
59849       {
59850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59851       };
59852     } catch (...) {
59853       {
59854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59855       };
59856     }
59857   }
59858 }
59859
59860
59861 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_ClearBackground(void * jarg1) {
59862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59863
59864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59865   {
59866     try {
59867       (arg1)->ClearBackground();
59868     } catch (std::out_of_range& e) {
59869       {
59870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59871       };
59872     } catch (std::exception& e) {
59873       {
59874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59875       };
59876     } catch (...) {
59877       {
59878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59879       };
59880     }
59881   }
59882 }
59883
59884
59885 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59887   Dali::Gesture::Type arg2 ;
59888
59889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59890   arg2 = (Dali::Gesture::Type)jarg2;
59891   {
59892     try {
59893       (arg1)->EnableGestureDetection(arg2);
59894     } catch (std::out_of_range& e) {
59895       {
59896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59897       };
59898     } catch (std::exception& e) {
59899       {
59900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59901       };
59902     } catch (...) {
59903       {
59904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59905       };
59906     }
59907   }
59908 }
59909
59910
59911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59913   Dali::Gesture::Type arg2 ;
59914
59915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59916   arg2 = (Dali::Gesture::Type)jarg2;
59917   {
59918     try {
59919       (arg1)->DisableGestureDetection(arg2);
59920     } catch (std::out_of_range& e) {
59921       {
59922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59923       };
59924     } catch (std::exception& e) {
59925       {
59926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59927       };
59928     } catch (...) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59931       };
59932     }
59933   }
59934 }
59935
59936
59937 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59938   void * jresult ;
59939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59940   Dali::PinchGestureDetector result;
59941
59942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59943   {
59944     try {
59945       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59946     } catch (std::out_of_range& e) {
59947       {
59948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59949       };
59950     } catch (std::exception& e) {
59951       {
59952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59953       };
59954     } catch (...) {
59955       {
59956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59957       };
59958     }
59959   }
59960   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59961   return jresult;
59962 }
59963
59964
59965 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetPanGestureDetector(void * jarg1) {
59966   void * jresult ;
59967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59968   Dali::PanGestureDetector result;
59969
59970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59971   {
59972     try {
59973       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59974     } catch (std::out_of_range& e) {
59975       {
59976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59977       };
59978     } catch (std::exception& e) {
59979       {
59980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (...) {
59983       {
59984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59985       };
59986     }
59987   }
59988   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59989   return jresult;
59990 }
59991
59992
59993 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetTapGestureDetector(void * jarg1) {
59994   void * jresult ;
59995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59996   Dali::TapGestureDetector result;
59997
59998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59999   {
60000     try {
60001       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60002     } catch (std::out_of_range& e) {
60003       {
60004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60005       };
60006     } catch (std::exception& e) {
60007       {
60008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60009       };
60010     } catch (...) {
60011       {
60012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60013       };
60014     }
60015   }
60016   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60017   return jresult;
60018 }
60019
60020
60021 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60022   void * jresult ;
60023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60024   Dali::LongPressGestureDetector result;
60025
60026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60027   {
60028     try {
60029       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60030     } catch (std::out_of_range& e) {
60031       {
60032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60033       };
60034     } catch (std::exception& e) {
60035       {
60036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60037       };
60038     } catch (...) {
60039       {
60040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60041       };
60042     }
60043   }
60044   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60045   return jresult;
60046 }
60047
60048
60049 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60051   bool arg2 ;
60052
60053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60054   arg2 = jarg2 ? true : false;
60055   {
60056     try {
60057       (arg1)->SetKeyboardNavigationSupport(arg2);
60058     } catch (std::out_of_range& e) {
60059       {
60060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60061       };
60062     } catch (std::exception& e) {
60063       {
60064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60065       };
60066     } catch (...) {
60067       {
60068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60069       };
60070     }
60071   }
60072 }
60073
60074
60075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60076   unsigned int jresult ;
60077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60078   bool result;
60079
60080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60081   {
60082     try {
60083       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (...) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60095       };
60096     }
60097   }
60098   jresult = result;
60099   return jresult;
60100 }
60101
60102
60103 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetKeyInputFocus(void * jarg1) {
60104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60105
60106   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60107   {
60108     try {
60109       (arg1)->SetKeyInputFocus();
60110     } catch (std::out_of_range& e) {
60111       {
60112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60113       };
60114     } catch (std::exception& e) {
60115       {
60116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60117       };
60118     } catch (...) {
60119       {
60120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60121       };
60122     }
60123   }
60124 }
60125
60126
60127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_HasKeyInputFocus(void * jarg1) {
60128   unsigned int jresult ;
60129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60130   bool result;
60131
60132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60133   {
60134     try {
60135       result = (bool)(arg1)->HasKeyInputFocus();
60136     } catch (std::out_of_range& e) {
60137       {
60138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60139       };
60140     } catch (std::exception& e) {
60141       {
60142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60143       };
60144     } catch (...) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60147       };
60148     }
60149   }
60150   jresult = result;
60151   return jresult;
60152 }
60153
60154
60155 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60157
60158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60159   {
60160     try {
60161       (arg1)->ClearKeyInputFocus();
60162     } catch (std::out_of_range& e) {
60163       {
60164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (std::exception& e) {
60167       {
60168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60169       };
60170     } catch (...) {
60171       {
60172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60173       };
60174     }
60175   }
60176 }
60177
60178
60179 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60181   bool arg2 ;
60182
60183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60184   arg2 = jarg2 ? true : false;
60185   {
60186     try {
60187       (arg1)->SetAsKeyboardFocusGroup(arg2);
60188     } catch (std::out_of_range& e) {
60189       {
60190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60191       };
60192     } catch (std::exception& e) {
60193       {
60194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60195       };
60196     } catch (...) {
60197       {
60198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60199       };
60200     }
60201   }
60202 }
60203
60204
60205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60206   unsigned int jresult ;
60207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60208   bool result;
60209
60210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60211   {
60212     try {
60213       result = (bool)(arg1)->IsKeyboardFocusGroup();
60214     } catch (std::out_of_range& e) {
60215       {
60216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60217       };
60218     } catch (std::exception& e) {
60219       {
60220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60221       };
60222     } catch (...) {
60223       {
60224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60225       };
60226     }
60227   }
60228   jresult = result;
60229   return jresult;
60230 }
60231
60232
60233 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_AccessibilityActivate(void * jarg1) {
60234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60235
60236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60237   {
60238     try {
60239       (arg1)->AccessibilityActivate();
60240     } catch (std::out_of_range& e) {
60241       {
60242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60243       };
60244     } catch (std::exception& e) {
60245       {
60246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60251       };
60252     }
60253   }
60254 }
60255
60256
60257 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_KeyboardEnter(void * jarg1) {
60258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60259
60260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60261   {
60262     try {
60263       (arg1)->KeyboardEnter();
60264     } catch (std::out_of_range& e) {
60265       {
60266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (std::exception& e) {
60269       {
60270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (...) {
60273       {
60274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60275       };
60276     }
60277   }
60278 }
60279
60280
60281 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyEventSignal(void * jarg1) {
60282   void * jresult ;
60283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60284   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60285
60286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60287   {
60288     try {
60289       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60290     } catch (std::out_of_range& e) {
60291       {
60292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60293       };
60294     } catch (std::exception& e) {
60295       {
60296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60297       };
60298     } catch (...) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60301       };
60302     }
60303   }
60304   jresult = (void *)result;
60305   return jresult;
60306 }
60307
60308
60309 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60310   void * jresult ;
60311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60312   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60313
60314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60315   {
60316     try {
60317       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60318     } catch (std::out_of_range& e) {
60319       {
60320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (std::exception& e) {
60323       {
60324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (...) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60329       };
60330     }
60331   }
60332   jresult = (void *)result;
60333   return jresult;
60334 }
60335
60336
60337 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60338   void * jresult ;
60339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60340   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60341
60342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60343   {
60344     try {
60345       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60346     } catch (std::out_of_range& e) {
60347       {
60348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60349       };
60350     } catch (std::exception& e) {
60351       {
60352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60353       };
60354     } catch (...) {
60355       {
60356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60357       };
60358     }
60359   }
60360   jresult = (void *)result;
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60366   unsigned int jresult ;
60367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60368   Dali::KeyEvent *arg2 = 0 ;
60369   bool result;
60370
60371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60372   arg2 = (Dali::KeyEvent *)jarg2;
60373   if (!arg2) {
60374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60375     return 0;
60376   }
60377   {
60378     try {
60379       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60380     } catch (std::out_of_range& e) {
60381       {
60382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (std::exception& e) {
60385       {
60386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60387       };
60388     } catch (...) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60391       };
60392     }
60393   }
60394   jresult = result;
60395   return jresult;
60396 }
60397
60398
60399 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60401   int arg2 ;
60402   SwigDirector_ViewImpl *darg = 0;
60403
60404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60405   arg2 = (int)jarg2;
60406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60407   {
60408     try {
60409       (darg)->OnStageConnection(arg2);
60410     } catch (std::out_of_range& e) {
60411       {
60412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60413       };
60414     } catch (std::exception& e) {
60415       {
60416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60417       };
60418     } catch (...) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60421       };
60422     }
60423   }
60424 }
60425
60426
60427 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60429   int arg2 ;
60430   SwigDirector_ViewImpl *darg = 0;
60431
60432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60433   arg2 = (int)jarg2;
60434   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60435   {
60436     try {
60437       (darg)->OnStageConnectionSwigPublic(arg2);
60438     } catch (std::out_of_range& e) {
60439       {
60440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60441       };
60442     } catch (std::exception& e) {
60443       {
60444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60445       };
60446     } catch (...) {
60447       {
60448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60449       };
60450     }
60451   }
60452 }
60453
60454
60455 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageDisconnection(void * jarg1) {
60456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60457   SwigDirector_ViewImpl *darg = 0;
60458
60459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60460   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60461   {
60462     try {
60463       (darg)->OnStageDisconnection();
60464     } catch (std::out_of_range& e) {
60465       {
60466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60467       };
60468     } catch (std::exception& e) {
60469       {
60470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60471       };
60472     } catch (...) {
60473       {
60474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60475       };
60476     }
60477   }
60478 }
60479
60480
60481 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60483   SwigDirector_ViewImpl *darg = 0;
60484
60485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60487   {
60488     try {
60489       (darg)->OnStageDisconnectionSwigPublic();
60490     } catch (std::out_of_range& e) {
60491       {
60492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60493       };
60494     } catch (std::exception& e) {
60495       {
60496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60497       };
60498     } catch (...) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60501       };
60502     }
60503   }
60504 }
60505
60506
60507 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60509   Dali::Actor *arg2 = 0 ;
60510   SwigDirector_ViewImpl *darg = 0;
60511
60512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60513   arg2 = (Dali::Actor *)jarg2;
60514   if (!arg2) {
60515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60516     return ;
60517   }
60518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60519   {
60520     try {
60521       (darg)->OnChildAdd(*arg2);
60522     } catch (std::out_of_range& e) {
60523       {
60524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60525       };
60526     } catch (std::exception& e) {
60527       {
60528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60529       };
60530     } catch (...) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60533       };
60534     }
60535   }
60536 }
60537
60538
60539 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60541   Dali::Actor *arg2 = 0 ;
60542   SwigDirector_ViewImpl *darg = 0;
60543
60544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60545   arg2 = (Dali::Actor *)jarg2;
60546   if (!arg2) {
60547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60548     return ;
60549   }
60550   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60551   {
60552     try {
60553       (darg)->OnChildAddSwigPublic(*arg2);
60554     } catch (std::out_of_range& e) {
60555       {
60556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60557       };
60558     } catch (std::exception& e) {
60559       {
60560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60565       };
60566     }
60567   }
60568 }
60569
60570
60571 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60573   Dali::Actor *arg2 = 0 ;
60574   SwigDirector_ViewImpl *darg = 0;
60575
60576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60577   arg2 = (Dali::Actor *)jarg2;
60578   if (!arg2) {
60579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60580     return ;
60581   }
60582   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60583   {
60584     try {
60585       (darg)->OnChildRemove(*arg2);
60586     } catch (std::out_of_range& e) {
60587       {
60588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60589       };
60590     } catch (std::exception& e) {
60591       {
60592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60593       };
60594     } catch (...) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60597       };
60598     }
60599   }
60600 }
60601
60602
60603 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60605   Dali::Actor *arg2 = 0 ;
60606   SwigDirector_ViewImpl *darg = 0;
60607
60608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60609   arg2 = (Dali::Actor *)jarg2;
60610   if (!arg2) {
60611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60612     return ;
60613   }
60614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60615   {
60616     try {
60617       (darg)->OnChildRemoveSwigPublic(*arg2);
60618     } catch (std::out_of_range& e) {
60619       {
60620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60621       };
60622     } catch (std::exception& e) {
60623       {
60624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60625       };
60626     } catch (...) {
60627       {
60628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60629       };
60630     }
60631   }
60632 }
60633
60634
60635 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60637   Dali::Property::Index arg2 ;
60638   Dali::Property::Value arg3 ;
60639   Dali::Property::Value *argp3 ;
60640   SwigDirector_ViewImpl *darg = 0;
60641
60642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60643   arg2 = (Dali::Property::Index)jarg2;
60644   argp3 = (Dali::Property::Value *)jarg3;
60645   if (!argp3) {
60646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60647     return ;
60648   }
60649   arg3 = *argp3;
60650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60651   {
60652     try {
60653       (darg)->OnPropertySet(arg2,arg3);
60654     } catch (std::out_of_range& e) {
60655       {
60656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60657       };
60658     } catch (std::exception& e) {
60659       {
60660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60661       };
60662     } catch (...) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60665       };
60666     }
60667   }
60668 }
60669
60670
60671 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60673   Dali::Property::Index arg2 ;
60674   Dali::Property::Value arg3 ;
60675   Dali::Property::Value *argp3 ;
60676   SwigDirector_ViewImpl *darg = 0;
60677
60678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60679   arg2 = (Dali::Property::Index)jarg2;
60680   argp3 = (Dali::Property::Value *)jarg3;
60681   if (!argp3) {
60682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60683     return ;
60684   }
60685   arg3 = *argp3;
60686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60687   {
60688     try {
60689       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60701       };
60702     }
60703   }
60704 }
60705
60706
60707 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60709   Dali::Vector3 *arg2 = 0 ;
60710   SwigDirector_ViewImpl *darg = 0;
60711
60712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60713   arg2 = (Dali::Vector3 *)jarg2;
60714   if (!arg2) {
60715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60716     return ;
60717   }
60718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60719   {
60720     try {
60721       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60722     } catch (std::out_of_range& e) {
60723       {
60724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60725       };
60726     } catch (std::exception& e) {
60727       {
60728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60729       };
60730     } catch (...) {
60731       {
60732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60733       };
60734     }
60735   }
60736 }
60737
60738
60739 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60741   Dali::Vector3 *arg2 = 0 ;
60742   SwigDirector_ViewImpl *darg = 0;
60743
60744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60745   arg2 = (Dali::Vector3 *)jarg2;
60746   if (!arg2) {
60747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60748     return ;
60749   }
60750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60751   {
60752     try {
60753       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60761       };
60762     } catch (...) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60765       };
60766     }
60767   }
60768 }
60769
60770
60771 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60773   Dali::Animation *arg2 = 0 ;
60774   Dali::Vector3 *arg3 = 0 ;
60775   SwigDirector_ViewImpl *darg = 0;
60776
60777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60778   arg2 = (Dali::Animation *)jarg2;
60779   if (!arg2) {
60780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60781     return ;
60782   }
60783   arg3 = (Dali::Vector3 *)jarg3;
60784   if (!arg3) {
60785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60786     return ;
60787   }
60788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60789   {
60790     try {
60791       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60792     } catch (std::out_of_range& e) {
60793       {
60794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60795       };
60796     } catch (std::exception& e) {
60797       {
60798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60799       };
60800     } catch (...) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60803       };
60804     }
60805   }
60806 }
60807
60808
60809 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60811   Dali::Animation *arg2 = 0 ;
60812   Dali::Vector3 *arg3 = 0 ;
60813   SwigDirector_ViewImpl *darg = 0;
60814
60815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60816   arg2 = (Dali::Animation *)jarg2;
60817   if (!arg2) {
60818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60819     return ;
60820   }
60821   arg3 = (Dali::Vector3 *)jarg3;
60822   if (!arg3) {
60823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60824     return ;
60825   }
60826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60827   {
60828     try {
60829       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60837       };
60838     } catch (...) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60841       };
60842     }
60843   }
60844 }
60845
60846
60847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60848   unsigned int jresult ;
60849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60850   Dali::TouchEvent *arg2 = 0 ;
60851   SwigDirector_ViewImpl *darg = 0;
60852   bool result;
60853
60854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60855   arg2 = (Dali::TouchEvent *)jarg2;
60856   if (!arg2) {
60857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60858     return 0;
60859   }
60860   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60861   {
60862     try {
60863       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60864     } catch (std::out_of_range& e) {
60865       {
60866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60867       };
60868     } catch (std::exception& e) {
60869       {
60870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60871       };
60872     } catch (...) {
60873       {
60874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60875       };
60876     }
60877   }
60878   jresult = result;
60879   return jresult;
60880 }
60881
60882
60883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60884   unsigned int jresult ;
60885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60886   Dali::TouchEvent *arg2 = 0 ;
60887   SwigDirector_ViewImpl *darg = 0;
60888   bool result;
60889
60890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60891   arg2 = (Dali::TouchEvent *)jarg2;
60892   if (!arg2) {
60893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60894     return 0;
60895   }
60896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60897   {
60898     try {
60899       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60900     } catch (std::out_of_range& e) {
60901       {
60902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (std::exception& e) {
60905       {
60906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60911       };
60912     }
60913   }
60914   jresult = result;
60915   return jresult;
60916 }
60917
60918
60919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60920   unsigned int jresult ;
60921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60922   Dali::HoverEvent *arg2 = 0 ;
60923   SwigDirector_ViewImpl *darg = 0;
60924   bool result;
60925
60926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60927   arg2 = (Dali::HoverEvent *)jarg2;
60928   if (!arg2) {
60929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60930     return 0;
60931   }
60932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60933   {
60934     try {
60935       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60936     } catch (std::out_of_range& e) {
60937       {
60938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60939       };
60940     } catch (std::exception& e) {
60941       {
60942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60943       };
60944     } catch (...) {
60945       {
60946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60947       };
60948     }
60949   }
60950   jresult = result;
60951   return jresult;
60952 }
60953
60954
60955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60956   unsigned int jresult ;
60957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60958   Dali::HoverEvent *arg2 = 0 ;
60959   SwigDirector_ViewImpl *darg = 0;
60960   bool result;
60961
60962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60963   arg2 = (Dali::HoverEvent *)jarg2;
60964   if (!arg2) {
60965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60966     return 0;
60967   }
60968   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60969   {
60970     try {
60971       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60972     } catch (std::out_of_range& e) {
60973       {
60974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60975       };
60976     } catch (std::exception& e) {
60977       {
60978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60979       };
60980     } catch (...) {
60981       {
60982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60983       };
60984     }
60985   }
60986   jresult = result;
60987   return jresult;
60988 }
60989
60990
60991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60992   unsigned int jresult ;
60993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60994   Dali::KeyEvent *arg2 = 0 ;
60995   SwigDirector_ViewImpl *darg = 0;
60996   bool result;
60997
60998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60999   arg2 = (Dali::KeyEvent *)jarg2;
61000   if (!arg2) {
61001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61002     return 0;
61003   }
61004   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61005   {
61006     try {
61007       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61008     } catch (std::out_of_range& e) {
61009       {
61010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61011       };
61012     } catch (std::exception& e) {
61013       {
61014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (...) {
61017       {
61018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61019       };
61020     }
61021   }
61022   jresult = result;
61023   return jresult;
61024 }
61025
61026
61027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61028   unsigned int jresult ;
61029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61030   Dali::KeyEvent *arg2 = 0 ;
61031   SwigDirector_ViewImpl *darg = 0;
61032   bool result;
61033
61034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61035   arg2 = (Dali::KeyEvent *)jarg2;
61036   if (!arg2) {
61037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61038     return 0;
61039   }
61040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61041   {
61042     try {
61043       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61044     } catch (std::out_of_range& e) {
61045       {
61046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61047       };
61048     } catch (std::exception& e) {
61049       {
61050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61051       };
61052     } catch (...) {
61053       {
61054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61055       };
61056     }
61057   }
61058   jresult = result;
61059   return jresult;
61060 }
61061
61062
61063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61064   unsigned int jresult ;
61065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61066   Dali::WheelEvent *arg2 = 0 ;
61067   SwigDirector_ViewImpl *darg = 0;
61068   bool result;
61069
61070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61071   arg2 = (Dali::WheelEvent *)jarg2;
61072   if (!arg2) {
61073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61074     return 0;
61075   }
61076   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61077   {
61078     try {
61079       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61080     } catch (std::out_of_range& e) {
61081       {
61082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61083       };
61084     } catch (std::exception& e) {
61085       {
61086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61087       };
61088     } catch (...) {
61089       {
61090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61091       };
61092     }
61093   }
61094   jresult = result;
61095   return jresult;
61096 }
61097
61098
61099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61100   unsigned int jresult ;
61101   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61102   Dali::WheelEvent *arg2 = 0 ;
61103   SwigDirector_ViewImpl *darg = 0;
61104   bool result;
61105
61106   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61107   arg2 = (Dali::WheelEvent *)jarg2;
61108   if (!arg2) {
61109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61110     return 0;
61111   }
61112   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61113   {
61114     try {
61115       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61116     } catch (std::out_of_range& e) {
61117       {
61118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61119       };
61120     } catch (std::exception& e) {
61121       {
61122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61123       };
61124     } catch (...) {
61125       {
61126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61127       };
61128     }
61129   }
61130   jresult = result;
61131   return jresult;
61132 }
61133
61134
61135 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61137   Dali::Vector2 *arg2 = 0 ;
61138   Dali::RelayoutContainer *arg3 = 0 ;
61139   SwigDirector_ViewImpl *darg = 0;
61140
61141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61142   arg2 = (Dali::Vector2 *)jarg2;
61143   if (!arg2) {
61144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61145     return ;
61146   }
61147   arg3 = (Dali::RelayoutContainer *)jarg3;
61148   if (!arg3) {
61149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61150     return ;
61151   }
61152   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61153   {
61154     try {
61155       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61156     } catch (std::out_of_range& e) {
61157       {
61158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61159       };
61160     } catch (std::exception& e) {
61161       {
61162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61163       };
61164     } catch (...) {
61165       {
61166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61167       };
61168     }
61169   }
61170 }
61171
61172
61173 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61175   Dali::Vector2 *arg2 = 0 ;
61176   Dali::RelayoutContainer *arg3 = 0 ;
61177   SwigDirector_ViewImpl *darg = 0;
61178
61179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61180   arg2 = (Dali::Vector2 *)jarg2;
61181   if (!arg2) {
61182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61183     return ;
61184   }
61185   arg3 = (Dali::RelayoutContainer *)jarg3;
61186   if (!arg3) {
61187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61188     return ;
61189   }
61190   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61191   {
61192     try {
61193       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61201       };
61202     } catch (...) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61205       };
61206     }
61207   }
61208 }
61209
61210
61211 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61213   Dali::ResizePolicy::Type arg2 ;
61214   Dali::Dimension::Type arg3 ;
61215   SwigDirector_ViewImpl *darg = 0;
61216
61217   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61218   arg2 = (Dali::ResizePolicy::Type)jarg2;
61219   arg3 = (Dali::Dimension::Type)jarg3;
61220   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61221   {
61222     try {
61223       (darg)->OnSetResizePolicy(arg2,arg3);
61224     } catch (std::out_of_range& e) {
61225       {
61226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61227       };
61228     } catch (std::exception& e) {
61229       {
61230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61231       };
61232     } catch (...) {
61233       {
61234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61235       };
61236     }
61237   }
61238 }
61239
61240
61241 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61242   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61243   Dali::ResizePolicy::Type arg2 ;
61244   Dali::Dimension::Type arg3 ;
61245   SwigDirector_ViewImpl *darg = 0;
61246
61247   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61248   arg2 = (Dali::ResizePolicy::Type)jarg2;
61249   arg3 = (Dali::Dimension::Type)jarg3;
61250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61251   {
61252     try {
61253       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61254     } catch (std::out_of_range& e) {
61255       {
61256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61257       };
61258     } catch (std::exception& e) {
61259       {
61260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61261       };
61262     } catch (...) {
61263       {
61264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61265       };
61266     }
61267   }
61268 }
61269
61270
61271 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNaturalSize(void * jarg1) {
61272   void * jresult ;
61273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61274   SwigDirector_ViewImpl *darg = 0;
61275   Dali::Vector3 result;
61276
61277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61278   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61279   {
61280     try {
61281       result = (darg)->GetNaturalSize();
61282     } catch (std::out_of_range& e) {
61283       {
61284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61285       };
61286     } catch (std::exception& e) {
61287       {
61288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61289       };
61290     } catch (...) {
61291       {
61292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61293       };
61294     }
61295   }
61296   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61297   return jresult;
61298 }
61299
61300
61301 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61302   void * jresult ;
61303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61304   SwigDirector_ViewImpl *darg = 0;
61305   Dali::Vector3 result;
61306
61307   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61308   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61309   {
61310     try {
61311       result = (darg)->GetNaturalSizeSwigPublic();
61312     } catch (std::out_of_range& e) {
61313       {
61314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61315       };
61316     } catch (std::exception& e) {
61317       {
61318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61319       };
61320     } catch (...) {
61321       {
61322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61323       };
61324     }
61325   }
61326   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61327   return jresult;
61328 }
61329
61330
61331 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61332   float jresult ;
61333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61334   Dali::Actor *arg2 = 0 ;
61335   Dali::Dimension::Type arg3 ;
61336   SwigDirector_ViewImpl *darg = 0;
61337   float result;
61338
61339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61340   arg2 = (Dali::Actor *)jarg2;
61341   if (!arg2) {
61342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61343     return 0;
61344   }
61345   arg3 = (Dali::Dimension::Type)jarg3;
61346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61347   {
61348     try {
61349       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61350     } catch (std::out_of_range& e) {
61351       {
61352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (std::exception& e) {
61355       {
61356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (...) {
61359       {
61360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61361       };
61362     }
61363   }
61364   jresult = result;
61365   return jresult;
61366 }
61367
61368
61369 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61370   float jresult ;
61371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61372   Dali::Actor *arg2 = 0 ;
61373   Dali::Dimension::Type arg3 ;
61374   SwigDirector_ViewImpl *darg = 0;
61375   float result;
61376
61377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61378   arg2 = (Dali::Actor *)jarg2;
61379   if (!arg2) {
61380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61381     return 0;
61382   }
61383   arg3 = (Dali::Dimension::Type)jarg3;
61384   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61385   {
61386     try {
61387       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61399       };
61400     }
61401   }
61402   jresult = result;
61403   return jresult;
61404 }
61405
61406
61407 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61408   float jresult ;
61409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61410   float arg2 ;
61411   SwigDirector_ViewImpl *darg = 0;
61412   float result;
61413
61414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61415   arg2 = (float)jarg2;
61416   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61417   {
61418     try {
61419       result = (float)(darg)->GetHeightForWidth(arg2);
61420     } catch (std::out_of_range& e) {
61421       {
61422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61423       };
61424     } catch (std::exception& e) {
61425       {
61426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (...) {
61429       {
61430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61431       };
61432     }
61433   }
61434   jresult = result;
61435   return jresult;
61436 }
61437
61438
61439 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61440   float jresult ;
61441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61442   float arg2 ;
61443   SwigDirector_ViewImpl *darg = 0;
61444   float result;
61445
61446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61447   arg2 = (float)jarg2;
61448   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61449   {
61450     try {
61451       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61452     } catch (std::out_of_range& e) {
61453       {
61454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61455       };
61456     } catch (std::exception& e) {
61457       {
61458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61459       };
61460     } catch (...) {
61461       {
61462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61463       };
61464     }
61465   }
61466   jresult = result;
61467   return jresult;
61468 }
61469
61470
61471 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61472   float jresult ;
61473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61474   float arg2 ;
61475   SwigDirector_ViewImpl *darg = 0;
61476   float result;
61477
61478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61479   arg2 = (float)jarg2;
61480   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61481   {
61482     try {
61483       result = (float)(darg)->GetWidthForHeight(arg2);
61484     } catch (std::out_of_range& e) {
61485       {
61486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61487       };
61488     } catch (std::exception& e) {
61489       {
61490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61491       };
61492     } catch (...) {
61493       {
61494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61495       };
61496     }
61497   }
61498   jresult = result;
61499   return jresult;
61500 }
61501
61502
61503 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61504   float jresult ;
61505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61506   float arg2 ;
61507   SwigDirector_ViewImpl *darg = 0;
61508   float result;
61509
61510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61511   arg2 = (float)jarg2;
61512   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61513   {
61514     try {
61515       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61516     } catch (std::out_of_range& e) {
61517       {
61518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61519       };
61520     } catch (std::exception& e) {
61521       {
61522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (...) {
61525       {
61526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61527       };
61528     }
61529   }
61530   jresult = result;
61531   return jresult;
61532 }
61533
61534
61535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61536   unsigned int jresult ;
61537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61538   Dali::Dimension::Type arg2 ;
61539   SwigDirector_ViewImpl *darg = 0;
61540   bool result;
61541
61542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61543   arg2 = (Dali::Dimension::Type)jarg2;
61544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61545   {
61546     try {
61547       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61548     } catch (std::out_of_range& e) {
61549       {
61550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61551       };
61552     } catch (std::exception& e) {
61553       {
61554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61555       };
61556     } catch (...) {
61557       {
61558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61559       };
61560     }
61561   }
61562   jresult = result;
61563   return jresult;
61564 }
61565
61566
61567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61568   unsigned int jresult ;
61569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61570   Dali::Dimension::Type arg2 ;
61571   SwigDirector_ViewImpl *darg = 0;
61572   bool result;
61573
61574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61575   arg2 = (Dali::Dimension::Type)jarg2;
61576   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61577   {
61578     try {
61579       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61580     } catch (std::out_of_range& e) {
61581       {
61582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61583       };
61584     } catch (std::exception& e) {
61585       {
61586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61587       };
61588     } catch (...) {
61589       {
61590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61591       };
61592     }
61593   }
61594   jresult = result;
61595   return jresult;
61596 }
61597
61598
61599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61600   unsigned int jresult ;
61601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61602   SwigDirector_ViewImpl *darg = 0;
61603   bool result;
61604
61605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61607   {
61608     try {
61609       result = (bool)(darg)->RelayoutDependentOnChildren();
61610     } catch (std::out_of_range& e) {
61611       {
61612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61613       };
61614     } catch (std::exception& e) {
61615       {
61616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61617       };
61618     } catch (...) {
61619       {
61620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61621       };
61622     }
61623   }
61624   jresult = result;
61625   return jresult;
61626 }
61627
61628
61629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61630   unsigned int jresult ;
61631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61632   SwigDirector_ViewImpl *darg = 0;
61633   bool result;
61634
61635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61637   {
61638     try {
61639       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61640     } catch (std::out_of_range& e) {
61641       {
61642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61643       };
61644     } catch (std::exception& e) {
61645       {
61646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61647       };
61648     } catch (...) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61651       };
61652     }
61653   }
61654   jresult = result;
61655   return jresult;
61656 }
61657
61658
61659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61661   Dali::Dimension::Type arg2 ;
61662   SwigDirector_ViewImpl *darg = 0;
61663
61664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61665   arg2 = (Dali::Dimension::Type)jarg2;
61666   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61667   {
61668     try {
61669       (darg)->OnCalculateRelayoutSize(arg2);
61670     } catch (std::out_of_range& e) {
61671       {
61672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61673       };
61674     } catch (std::exception& e) {
61675       {
61676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61677       };
61678     } catch (...) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61681       };
61682     }
61683   }
61684 }
61685
61686
61687 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61689   Dali::Dimension::Type arg2 ;
61690   SwigDirector_ViewImpl *darg = 0;
61691
61692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61693   arg2 = (Dali::Dimension::Type)jarg2;
61694   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61695   {
61696     try {
61697       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61698     } catch (std::out_of_range& e) {
61699       {
61700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61701       };
61702     } catch (std::exception& e) {
61703       {
61704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61705       };
61706     } catch (...) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61709       };
61710     }
61711   }
61712 }
61713
61714
61715 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61717   float arg2 ;
61718   Dali::Dimension::Type arg3 ;
61719   SwigDirector_ViewImpl *darg = 0;
61720
61721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61722   arg2 = (float)jarg2;
61723   arg3 = (Dali::Dimension::Type)jarg3;
61724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61725   {
61726     try {
61727       (darg)->OnLayoutNegotiated(arg2,arg3);
61728     } catch (std::out_of_range& e) {
61729       {
61730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61731       };
61732     } catch (std::exception& e) {
61733       {
61734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61735       };
61736     } catch (...) {
61737       {
61738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61739       };
61740     }
61741   }
61742 }
61743
61744
61745 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61747   float arg2 ;
61748   Dali::Dimension::Type arg3 ;
61749   SwigDirector_ViewImpl *darg = 0;
61750
61751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61752   arg2 = (float)jarg2;
61753   arg3 = (Dali::Dimension::Type)jarg3;
61754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61755   {
61756     try {
61757       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61758     } catch (std::out_of_range& e) {
61759       {
61760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61761       };
61762     } catch (std::exception& e) {
61763       {
61764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61765       };
61766     } catch (...) {
61767       {
61768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61769       };
61770     }
61771   }
61772 }
61773
61774
61775 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnInitialize(void * jarg1) {
61776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61777
61778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61779   {
61780     try {
61781       (arg1)->OnInitialize();
61782     } catch (std::out_of_range& e) {
61783       {
61784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61785       };
61786     } catch (std::exception& e) {
61787       {
61788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61789       };
61790     } catch (...) {
61791       {
61792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61793       };
61794     }
61795   }
61796 }
61797
61798
61799 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61801
61802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61803   {
61804     try {
61805       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61806     } catch (std::out_of_range& e) {
61807       {
61808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61809       };
61810     } catch (std::exception& e) {
61811       {
61812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61813       };
61814     } catch (...) {
61815       {
61816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61817       };
61818     }
61819   }
61820 }
61821
61822
61823 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61825   Dali::Actor *arg2 = 0 ;
61826
61827   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61828   arg2 = (Dali::Actor *)jarg2;
61829   if (!arg2) {
61830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61831     return ;
61832   }
61833   {
61834     try {
61835       (arg1)->OnControlChildAdd(*arg2);
61836     } catch (std::out_of_range& e) {
61837       {
61838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61839       };
61840     } catch (std::exception& e) {
61841       {
61842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61843       };
61844     } catch (...) {
61845       {
61846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61847       };
61848     }
61849   }
61850 }
61851
61852
61853 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61855   Dali::Actor *arg2 = 0 ;
61856
61857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61858   arg2 = (Dali::Actor *)jarg2;
61859   if (!arg2) {
61860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61861     return ;
61862   }
61863   {
61864     try {
61865       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61873       };
61874     } catch (...) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61877       };
61878     }
61879   }
61880 }
61881
61882
61883 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61885   Dali::Actor *arg2 = 0 ;
61886
61887   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61888   arg2 = (Dali::Actor *)jarg2;
61889   if (!arg2) {
61890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61891     return ;
61892   }
61893   {
61894     try {
61895       (arg1)->OnControlChildRemove(*arg2);
61896     } catch (std::out_of_range& e) {
61897       {
61898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61899       };
61900     } catch (std::exception& e) {
61901       {
61902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61903       };
61904     } catch (...) {
61905       {
61906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61907       };
61908     }
61909   }
61910 }
61911
61912
61913 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61915   Dali::Actor *arg2 = 0 ;
61916
61917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61918   arg2 = (Dali::Actor *)jarg2;
61919   if (!arg2) {
61920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61921     return ;
61922   }
61923   {
61924     try {
61925       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61926     } catch (std::out_of_range& e) {
61927       {
61928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61929       };
61930     } catch (std::exception& e) {
61931       {
61932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61933       };
61934     } catch (...) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61937       };
61938     }
61939   }
61940 }
61941
61942
61943 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61945   Dali::Toolkit::StyleManager arg2 ;
61946   Dali::StyleChange::Type arg3 ;
61947   Dali::Toolkit::StyleManager *argp2 ;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61951   if (!argp2) {
61952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61953     return ;
61954   }
61955   arg2 = *argp2;
61956   arg3 = (Dali::StyleChange::Type)jarg3;
61957   {
61958     try {
61959       (arg1)->OnStyleChange(arg2,arg3);
61960     } catch (std::out_of_range& e) {
61961       {
61962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61963       };
61964     } catch (std::exception& e) {
61965       {
61966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61967       };
61968     } catch (...) {
61969       {
61970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61971       };
61972     }
61973   }
61974 }
61975
61976
61977 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61979   Dali::Toolkit::StyleManager arg2 ;
61980   Dali::StyleChange::Type arg3 ;
61981   Dali::Toolkit::StyleManager *argp2 ;
61982
61983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61984   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61985   if (!argp2) {
61986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61987     return ;
61988   }
61989   arg2 = *argp2;
61990   arg3 = (Dali::StyleChange::Type)jarg3;
61991   {
61992     try {
61993       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61994     } catch (std::out_of_range& e) {
61995       {
61996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61997       };
61998     } catch (std::exception& e) {
61999       {
62000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62001       };
62002     } catch (...) {
62003       {
62004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62005       };
62006     }
62007   }
62008 }
62009
62010
62011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62012   unsigned int jresult ;
62013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62014   bool result;
62015
62016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62017   {
62018     try {
62019       result = (bool)(arg1)->OnAccessibilityActivated();
62020     } catch (std::out_of_range& e) {
62021       {
62022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62023       };
62024     } catch (std::exception& e) {
62025       {
62026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62027       };
62028     } catch (...) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62031       };
62032     }
62033   }
62034   jresult = result;
62035   return jresult;
62036 }
62037
62038
62039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62040   unsigned int jresult ;
62041   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62042   bool result;
62043
62044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62045   {
62046     try {
62047       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62055       };
62056     } catch (...) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62059       };
62060     }
62061   }
62062   jresult = result;
62063   return jresult;
62064 }
62065
62066
62067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62068   unsigned int jresult ;
62069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62070   Dali::PanGesture arg2 ;
62071   Dali::PanGesture *argp2 ;
62072   bool result;
62073
62074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62075   argp2 = (Dali::PanGesture *)jarg2;
62076   if (!argp2) {
62077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62078     return 0;
62079   }
62080   arg2 = *argp2;
62081   {
62082     try {
62083       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62084     } catch (std::out_of_range& e) {
62085       {
62086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62087       };
62088     } catch (std::exception& e) {
62089       {
62090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62091       };
62092     } catch (...) {
62093       {
62094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62095       };
62096     }
62097   }
62098   jresult = result;
62099   return jresult;
62100 }
62101
62102
62103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62104   unsigned int jresult ;
62105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62106   Dali::PanGesture arg2 ;
62107   Dali::PanGesture *argp2 ;
62108   bool result;
62109
62110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62111   argp2 = (Dali::PanGesture *)jarg2;
62112   if (!argp2) {
62113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62114     return 0;
62115   }
62116   arg2 = *argp2;
62117   {
62118     try {
62119       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62120     } catch (std::out_of_range& e) {
62121       {
62122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62123       };
62124     } catch (std::exception& e) {
62125       {
62126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62127       };
62128     } catch (...) {
62129       {
62130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62131       };
62132     }
62133   }
62134   jresult = result;
62135   return jresult;
62136 }
62137
62138
62139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62140   unsigned int jresult ;
62141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62142   Dali::TouchEvent *arg2 = 0 ;
62143   bool result;
62144
62145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62146   arg2 = (Dali::TouchEvent *)jarg2;
62147   if (!arg2) {
62148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62149     return 0;
62150   }
62151   {
62152     try {
62153       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62154     } catch (std::out_of_range& e) {
62155       {
62156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62157       };
62158     } catch (std::exception& e) {
62159       {
62160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62161       };
62162     } catch (...) {
62163       {
62164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62165       };
62166     }
62167   }
62168   jresult = result;
62169   return jresult;
62170 }
62171
62172
62173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62174   unsigned int jresult ;
62175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62176   Dali::TouchEvent *arg2 = 0 ;
62177   bool result;
62178
62179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62180   arg2 = (Dali::TouchEvent *)jarg2;
62181   if (!arg2) {
62182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62183     return 0;
62184   }
62185   {
62186     try {
62187       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62188     } catch (std::out_of_range& e) {
62189       {
62190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62191       };
62192     } catch (std::exception& e) {
62193       {
62194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62195       };
62196     } catch (...) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62199       };
62200     }
62201   }
62202   jresult = result;
62203   return jresult;
62204 }
62205
62206
62207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62208   unsigned int jresult ;
62209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62210   bool arg2 ;
62211   bool result;
62212
62213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62214   arg2 = jarg2 ? true : false;
62215   {
62216     try {
62217       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62218     } catch (std::out_of_range& e) {
62219       {
62220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62221       };
62222     } catch (std::exception& e) {
62223       {
62224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (...) {
62227       {
62228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62229       };
62230     }
62231   }
62232   jresult = result;
62233   return jresult;
62234 }
62235
62236
62237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62238   unsigned int jresult ;
62239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62240   bool arg2 ;
62241   bool result;
62242
62243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62244   arg2 = jarg2 ? true : false;
62245   {
62246     try {
62247       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62248     } catch (std::out_of_range& e) {
62249       {
62250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62251       };
62252     } catch (std::exception& e) {
62253       {
62254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62255       };
62256     } catch (...) {
62257       {
62258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62259       };
62260     }
62261   }
62262   jresult = result;
62263   return jresult;
62264 }
62265
62266
62267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62268   unsigned int jresult ;
62269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62270   bool result;
62271
62272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62273   {
62274     try {
62275       result = (bool)(arg1)->OnAccessibilityZoom();
62276     } catch (std::out_of_range& e) {
62277       {
62278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62279       };
62280     } catch (std::exception& e) {
62281       {
62282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62283       };
62284     } catch (...) {
62285       {
62286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62287       };
62288     }
62289   }
62290   jresult = result;
62291   return jresult;
62292 }
62293
62294
62295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62296   unsigned int jresult ;
62297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62298   bool result;
62299
62300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62301   {
62302     try {
62303       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62315       };
62316     }
62317   }
62318   jresult = result;
62319   return jresult;
62320 }
62321
62322
62323 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62325
62326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62327   {
62328     try {
62329       (arg1)->OnKeyInputFocusGained();
62330     } catch (std::out_of_range& e) {
62331       {
62332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62333       };
62334     } catch (std::exception& e) {
62335       {
62336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62337       };
62338     } catch (...) {
62339       {
62340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62341       };
62342     }
62343   }
62344 }
62345
62346
62347 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62349
62350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62351   {
62352     try {
62353       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62354     } catch (std::out_of_range& e) {
62355       {
62356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62357       };
62358     } catch (std::exception& e) {
62359       {
62360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62361       };
62362     } catch (...) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62365       };
62366     }
62367   }
62368 }
62369
62370
62371 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62373
62374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62375   {
62376     try {
62377       (arg1)->OnKeyInputFocusLost();
62378     } catch (std::out_of_range& e) {
62379       {
62380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62381       };
62382     } catch (std::exception& e) {
62383       {
62384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62385       };
62386     } catch (...) {
62387       {
62388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62389       };
62390     }
62391   }
62392 }
62393
62394
62395 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62397
62398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62399   {
62400     try {
62401       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62402     } catch (std::out_of_range& e) {
62403       {
62404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62405       };
62406     } catch (std::exception& e) {
62407       {
62408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (...) {
62411       {
62412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62413       };
62414     }
62415   }
62416 }
62417
62418
62419 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62420   void * jresult ;
62421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62422   Dali::Actor arg2 ;
62423   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62424   bool arg4 ;
62425   Dali::Actor *argp2 ;
62426   Dali::Actor result;
62427
62428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62429   argp2 = (Dali::Actor *)jarg2;
62430   if (!argp2) {
62431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62432     return 0;
62433   }
62434   arg2 = *argp2;
62435   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62436   arg4 = jarg4 ? true : false;
62437   {
62438     try {
62439       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62440     } catch (std::out_of_range& e) {
62441       {
62442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62443       };
62444     } catch (std::exception& e) {
62445       {
62446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62447       };
62448     } catch (...) {
62449       {
62450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62451       };
62452     }
62453   }
62454   jresult = new Dali::Actor((const Dali::Actor &)result);
62455   return jresult;
62456 }
62457
62458
62459 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62460   void * jresult ;
62461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62462   Dali::Actor arg2 ;
62463   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62464   bool arg4 ;
62465   Dali::Actor *argp2 ;
62466   Dali::Actor result;
62467
62468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62469   argp2 = (Dali::Actor *)jarg2;
62470   if (!argp2) {
62471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62472     return 0;
62473   }
62474   arg2 = *argp2;
62475   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62476   arg4 = jarg4 ? true : false;
62477   {
62478     try {
62479       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62480     } catch (std::out_of_range& e) {
62481       {
62482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62483       };
62484     } catch (std::exception& e) {
62485       {
62486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62491       };
62492     }
62493   }
62494   jresult = new Dali::Actor((const Dali::Actor &)result);
62495   return jresult;
62496 }
62497
62498
62499 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62501   Dali::Actor arg2 ;
62502   Dali::Actor *argp2 ;
62503
62504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62505   argp2 = (Dali::Actor *)jarg2;
62506   if (!argp2) {
62507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62508     return ;
62509   }
62510   arg2 = *argp2;
62511   {
62512     try {
62513       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62514     } catch (std::out_of_range& e) {
62515       {
62516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62517       };
62518     } catch (std::exception& e) {
62519       {
62520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62521       };
62522     } catch (...) {
62523       {
62524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62525       };
62526     }
62527   }
62528 }
62529
62530
62531 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62533   Dali::Actor arg2 ;
62534   Dali::Actor *argp2 ;
62535
62536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62537   argp2 = (Dali::Actor *)jarg2;
62538   if (!argp2) {
62539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62540     return ;
62541   }
62542   arg2 = *argp2;
62543   {
62544     try {
62545       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62546     } catch (std::out_of_range& e) {
62547       {
62548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62549       };
62550     } catch (std::exception& e) {
62551       {
62552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62553       };
62554     } catch (...) {
62555       {
62556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62557       };
62558     }
62559   }
62560 }
62561
62562
62563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardEnter(void * jarg1) {
62564   unsigned int jresult ;
62565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62566   bool result;
62567
62568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62569   {
62570     try {
62571       result = (bool)(arg1)->OnKeyboardEnter();
62572     } catch (std::out_of_range& e) {
62573       {
62574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (std::exception& e) {
62577       {
62578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62579       };
62580     } catch (...) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62583       };
62584     }
62585   }
62586   jresult = result;
62587   return jresult;
62588 }
62589
62590
62591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62592   unsigned int jresult ;
62593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62594   bool result;
62595
62596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62597   {
62598     try {
62599       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62600     } catch (std::out_of_range& e) {
62601       {
62602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62603       };
62604     } catch (std::exception& e) {
62605       {
62606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62607       };
62608     } catch (...) {
62609       {
62610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62611       };
62612     }
62613   }
62614   jresult = result;
62615   return jresult;
62616 }
62617
62618
62619 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62621   Dali::PinchGesture *arg2 = 0 ;
62622
62623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62624   arg2 = (Dali::PinchGesture *)jarg2;
62625   if (!arg2) {
62626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62627     return ;
62628   }
62629   {
62630     try {
62631       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62632     } catch (std::out_of_range& e) {
62633       {
62634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62635       };
62636     } catch (std::exception& e) {
62637       {
62638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62639       };
62640     } catch (...) {
62641       {
62642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62643       };
62644     }
62645   }
62646 }
62647
62648
62649 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62650   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62651   Dali::PinchGesture *arg2 = 0 ;
62652
62653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62654   arg2 = (Dali::PinchGesture *)jarg2;
62655   if (!arg2) {
62656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62657     return ;
62658   }
62659   {
62660     try {
62661       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62662     } catch (std::out_of_range& e) {
62663       {
62664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62665       };
62666     } catch (std::exception& e) {
62667       {
62668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62669       };
62670     } catch (...) {
62671       {
62672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62673       };
62674     }
62675   }
62676 }
62677
62678
62679 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62681   Dali::PanGesture *arg2 = 0 ;
62682
62683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62684   arg2 = (Dali::PanGesture *)jarg2;
62685   if (!arg2) {
62686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62687     return ;
62688   }
62689   {
62690     try {
62691       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62692     } catch (std::out_of_range& e) {
62693       {
62694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62695       };
62696     } catch (std::exception& e) {
62697       {
62698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62699       };
62700     } catch (...) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62703       };
62704     }
62705   }
62706 }
62707
62708
62709 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62711   Dali::PanGesture *arg2 = 0 ;
62712
62713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62714   arg2 = (Dali::PanGesture *)jarg2;
62715   if (!arg2) {
62716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62717     return ;
62718   }
62719   {
62720     try {
62721       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62722     } catch (std::out_of_range& e) {
62723       {
62724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62725       };
62726     } catch (std::exception& e) {
62727       {
62728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62733       };
62734     }
62735   }
62736 }
62737
62738
62739 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62741   Dali::TapGesture *arg2 = 0 ;
62742
62743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62744   arg2 = (Dali::TapGesture *)jarg2;
62745   if (!arg2) {
62746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62747     return ;
62748   }
62749   {
62750     try {
62751       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62752     } catch (std::out_of_range& e) {
62753       {
62754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62755       };
62756     } catch (std::exception& e) {
62757       {
62758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62759       };
62760     } catch (...) {
62761       {
62762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62763       };
62764     }
62765   }
62766 }
62767
62768
62769 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62771   Dali::TapGesture *arg2 = 0 ;
62772
62773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62774   arg2 = (Dali::TapGesture *)jarg2;
62775   if (!arg2) {
62776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62777     return ;
62778   }
62779   {
62780     try {
62781       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62782     } catch (std::out_of_range& e) {
62783       {
62784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62785       };
62786     } catch (std::exception& e) {
62787       {
62788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62789       };
62790     } catch (...) {
62791       {
62792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62793       };
62794     }
62795   }
62796 }
62797
62798
62799 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62801   Dali::LongPressGesture *arg2 = 0 ;
62802
62803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62804   arg2 = (Dali::LongPressGesture *)jarg2;
62805   if (!arg2) {
62806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62807     return ;
62808   }
62809   {
62810     try {
62811       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62812     } catch (std::out_of_range& e) {
62813       {
62814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62815       };
62816     } catch (std::exception& e) {
62817       {
62818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62819       };
62820     } catch (...) {
62821       {
62822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62823       };
62824     }
62825   }
62826 }
62827
62828
62829 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62831   Dali::LongPressGesture *arg2 = 0 ;
62832
62833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62834   arg2 = (Dali::LongPressGesture *)jarg2;
62835   if (!arg2) {
62836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62837     return ;
62838   }
62839   {
62840     try {
62841       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62849       };
62850     } catch (...) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62853       };
62854     }
62855   }
62856 }
62857
62858
62859 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62861   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62862   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62863
62864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62865   arg2 = (Dali::SlotObserver *)jarg2;
62866   arg3 = (Dali::CallbackBase *)jarg3;
62867   {
62868     try {
62869       (arg1)->SignalConnected(arg2,arg3);
62870     } catch (std::out_of_range& e) {
62871       {
62872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62873       };
62874     } catch (std::exception& e) {
62875       {
62876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62877       };
62878     } catch (...) {
62879       {
62880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62881       };
62882     }
62883   }
62884 }
62885
62886
62887 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62889   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62890   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62891
62892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62893   arg2 = (Dali::SlotObserver *)jarg2;
62894   arg3 = (Dali::CallbackBase *)jarg3;
62895   {
62896     try {
62897       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62898     } catch (std::out_of_range& e) {
62899       {
62900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62901       };
62902     } catch (std::exception& e) {
62903       {
62904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62905       };
62906     } catch (...) {
62907       {
62908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62909       };
62910     }
62911   }
62912 }
62913
62914
62915 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62917   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62918   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62919
62920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62921   arg2 = (Dali::SlotObserver *)jarg2;
62922   arg3 = (Dali::CallbackBase *)jarg3;
62923   {
62924     try {
62925       (arg1)->SignalDisconnected(arg2,arg3);
62926     } catch (std::out_of_range& e) {
62927       {
62928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62929       };
62930     } catch (std::exception& e) {
62931       {
62932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62933       };
62934     } catch (...) {
62935       {
62936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62937       };
62938     }
62939   }
62940 }
62941
62942
62943 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62945   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62946   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62947
62948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62949   arg2 = (Dali::SlotObserver *)jarg2;
62950   arg3 = (Dali::CallbackBase *)jarg3;
62951   {
62952     try {
62953       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62954     } catch (std::out_of_range& e) {
62955       {
62956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62957       };
62958     } catch (std::exception& e) {
62959       {
62960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62961       };
62962     } catch (...) {
62963       {
62964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62965       };
62966     }
62967   }
62968 }
62969
62970
62971 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) {
62972   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62973   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62974   if (director) {
62975     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);
62976   }
62977 }
62978
62979
62980 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GetImplementation__SWIG_0(void * jarg1) {
62981   void * jresult ;
62982   Dali::Toolkit::Control *arg1 = 0 ;
62983   Dali::Toolkit::Internal::Control *result = 0 ;
62984
62985   arg1 = (Dali::Toolkit::Control *)jarg1;
62986   if (!arg1) {
62987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62988     return 0;
62989   }
62990   {
62991     try {
62992       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62993     } catch (std::out_of_range& e) {
62994       {
62995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62996       };
62997     } catch (std::exception& e) {
62998       {
62999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63000       };
63001     } catch (...) {
63002       {
63003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63004       };
63005     }
63006   }
63007   jresult = (void *)result;
63008   return jresult;
63009 }
63010
63011
63012 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_STYLE_NAME_get() {
63013   int jresult ;
63014   int result;
63015
63016   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63017   jresult = (int)result;
63018   return jresult;
63019 }
63020
63021
63022 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_COLOR_get() {
63023   int jresult ;
63024   int result;
63025
63026   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63027   jresult = (int)result;
63028   return jresult;
63029 }
63030
63031
63032 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_IMAGE_get() {
63033   int jresult ;
63034   int result;
63035
63036   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63037   jresult = (int)result;
63038   return jresult;
63039 }
63040
63041
63042 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_KEY_INPUT_FOCUS_get() {
63043   int jresult ;
63044   int result;
63045
63046   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63047   jresult = (int)result;
63048   return jresult;
63049 }
63050
63051
63052 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_View_Property_BACKGROUND_get() {
63053   int jresult ;
63054   int result;
63055
63056   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63057   jresult = (int)result;
63058   return jresult;
63059 }
63060
63061
63062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View_Property() {
63063   void * jresult ;
63064   Dali::Toolkit::Control::Property *result = 0 ;
63065
63066   {
63067     try {
63068       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63069     } catch (std::out_of_range& e) {
63070       {
63071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63072       };
63073     } catch (std::exception& e) {
63074       {
63075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63076       };
63077     } catch (...) {
63078       {
63079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63080       };
63081     }
63082   }
63083   jresult = (void *)result;
63084   return jresult;
63085 }
63086
63087
63088 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View_Property(void * jarg1) {
63089   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63090
63091   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63092   {
63093     try {
63094       delete arg1;
63095     } catch (std::out_of_range& e) {
63096       {
63097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63098       };
63099     } catch (std::exception& e) {
63100       {
63101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63102       };
63103     } catch (...) {
63104       {
63105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63106       };
63107     }
63108   }
63109 }
63110
63111
63112 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View_KeyboardFocus() {
63113   void * jresult ;
63114   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63115
63116   {
63117     try {
63118       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63119     } catch (std::out_of_range& e) {
63120       {
63121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63122       };
63123     } catch (std::exception& e) {
63124       {
63125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63126       };
63127     } catch (...) {
63128       {
63129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63130       };
63131     }
63132   }
63133   jresult = (void *)result;
63134   return jresult;
63135 }
63136
63137
63138 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View_KeyboardFocus(void * jarg1) {
63139   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63140
63141   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63142   {
63143     try {
63144       delete arg1;
63145     } catch (std::out_of_range& e) {
63146       {
63147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63148       };
63149     } catch (std::exception& e) {
63150       {
63151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63152       };
63153     } catch (...) {
63154       {
63155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63156       };
63157     }
63158   }
63159 }
63160
63161
63162 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_New() {
63163   void * jresult ;
63164   Dali::Toolkit::Control result;
63165
63166   {
63167     try {
63168       result = Dali::Toolkit::Control::New();
63169     } catch (std::out_of_range& e) {
63170       {
63171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63172       };
63173     } catch (std::exception& e) {
63174       {
63175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63176       };
63177     } catch (...) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63180       };
63181     }
63182   }
63183   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63184   return jresult;
63185 }
63186
63187
63188 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_0() {
63189   void * jresult ;
63190   Dali::Toolkit::Control *result = 0 ;
63191
63192   {
63193     try {
63194       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63195     } catch (std::out_of_range& e) {
63196       {
63197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63198       };
63199     } catch (std::exception& e) {
63200       {
63201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63202       };
63203     } catch (...) {
63204       {
63205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63206       };
63207     }
63208   }
63209   jresult = (void *)result;
63210   return jresult;
63211 }
63212
63213
63214 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_1(void * jarg1) {
63215   void * jresult ;
63216   Dali::Toolkit::Control *arg1 = 0 ;
63217   Dali::Toolkit::Control *result = 0 ;
63218
63219   arg1 = (Dali::Toolkit::Control *)jarg1;
63220   if (!arg1) {
63221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63222     return 0;
63223   }
63224   {
63225     try {
63226       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63227     } catch (std::out_of_range& e) {
63228       {
63229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63230       };
63231     } catch (std::exception& e) {
63232       {
63233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (...) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63238       };
63239     }
63240   }
63241   jresult = (void *)result;
63242   return jresult;
63243 }
63244
63245
63246 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_View(void * jarg1) {
63247   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63248
63249   arg1 = (Dali::Toolkit::Control *)jarg1;
63250   {
63251     try {
63252       delete arg1;
63253     } catch (std::out_of_range& e) {
63254       {
63255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63256       };
63257     } catch (std::exception& e) {
63258       {
63259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63260       };
63261     } catch (...) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63264       };
63265     }
63266   }
63267 }
63268
63269
63270 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_Assign(void * jarg1, void * jarg2) {
63271   void * jresult ;
63272   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63273   Dali::Toolkit::Control *arg2 = 0 ;
63274   Dali::Toolkit::Control *result = 0 ;
63275
63276   arg1 = (Dali::Toolkit::Control *)jarg1;
63277   arg2 = (Dali::Toolkit::Control *)jarg2;
63278   if (!arg2) {
63279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63280     return 0;
63281   }
63282   {
63283     try {
63284       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63285     } catch (std::out_of_range& e) {
63286       {
63287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63288       };
63289     } catch (std::exception& e) {
63290       {
63291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63292       };
63293     } catch (...) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63296       };
63297     }
63298   }
63299   jresult = (void *)result;
63300   return jresult;
63301 }
63302
63303
63304 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_DownCast(void * jarg1) {
63305   void * jresult ;
63306   Dali::BaseHandle arg1 ;
63307   Dali::BaseHandle *argp1 ;
63308   Dali::Toolkit::Control result;
63309
63310   argp1 = (Dali::BaseHandle *)jarg1;
63311   if (!argp1) {
63312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63313     return 0;
63314   }
63315   arg1 = *argp1;
63316   {
63317     try {
63318       result = Dali::Toolkit::Control::DownCast(arg1);
63319     } catch (std::out_of_range& e) {
63320       {
63321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63322       };
63323     } catch (std::exception& e) {
63324       {
63325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63326       };
63327     } catch (...) {
63328       {
63329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63330       };
63331     }
63332   }
63333   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63334   return jresult;
63335 }
63336
63337
63338 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetKeyInputFocus(void * jarg1) {
63339   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63340
63341   arg1 = (Dali::Toolkit::Control *)jarg1;
63342   {
63343     try {
63344       (arg1)->SetKeyInputFocus();
63345     } catch (std::out_of_range& e) {
63346       {
63347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63348       };
63349     } catch (std::exception& e) {
63350       {
63351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63356       };
63357     }
63358   }
63359 }
63360
63361
63362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_View_HasKeyInputFocus(void * jarg1) {
63363   unsigned int jresult ;
63364   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63365   bool result;
63366
63367   arg1 = (Dali::Toolkit::Control *)jarg1;
63368   {
63369     try {
63370       result = (bool)(arg1)->HasKeyInputFocus();
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (...) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63382       };
63383     }
63384   }
63385   jresult = result;
63386   return jresult;
63387 }
63388
63389
63390 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_ClearKeyInputFocus(void * jarg1) {
63391   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63392
63393   arg1 = (Dali::Toolkit::Control *)jarg1;
63394   {
63395     try {
63396       (arg1)->ClearKeyInputFocus();
63397     } catch (std::out_of_range& e) {
63398       {
63399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63400       };
63401     } catch (std::exception& e) {
63402       {
63403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63404       };
63405     } catch (...) {
63406       {
63407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63408       };
63409     }
63410   }
63411 }
63412
63413
63414 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetPinchGestureDetector(void * jarg1) {
63415   void * jresult ;
63416   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63417   Dali::PinchGestureDetector result;
63418
63419   arg1 = (Dali::Toolkit::Control *)jarg1;
63420   {
63421     try {
63422       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63423     } catch (std::out_of_range& e) {
63424       {
63425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63426       };
63427     } catch (std::exception& e) {
63428       {
63429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63430       };
63431     } catch (...) {
63432       {
63433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63434       };
63435     }
63436   }
63437   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63438   return jresult;
63439 }
63440
63441
63442 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetPanGestureDetector(void * jarg1) {
63443   void * jresult ;
63444   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63445   Dali::PanGestureDetector result;
63446
63447   arg1 = (Dali::Toolkit::Control *)jarg1;
63448   {
63449     try {
63450       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63451     } catch (std::out_of_range& e) {
63452       {
63453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63454       };
63455     } catch (std::exception& e) {
63456       {
63457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63458       };
63459     } catch (...) {
63460       {
63461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63462       };
63463     }
63464   }
63465   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63466   return jresult;
63467 }
63468
63469
63470 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetTapGestureDetector(void * jarg1) {
63471   void * jresult ;
63472   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63473   Dali::TapGestureDetector result;
63474
63475   arg1 = (Dali::Toolkit::Control *)jarg1;
63476   {
63477     try {
63478       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63479     } catch (std::out_of_range& e) {
63480       {
63481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63482       };
63483     } catch (std::exception& e) {
63484       {
63485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63486       };
63487     } catch (...) {
63488       {
63489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63490       };
63491     }
63492   }
63493   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63494   return jresult;
63495 }
63496
63497
63498 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetLongPressGestureDetector(void * jarg1) {
63499   void * jresult ;
63500   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63501   Dali::LongPressGestureDetector result;
63502
63503   arg1 = (Dali::Toolkit::Control *)jarg1;
63504   {
63505     try {
63506       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63507     } catch (std::out_of_range& e) {
63508       {
63509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63510       };
63511     } catch (std::exception& e) {
63512       {
63513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63514       };
63515     } catch (...) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63518       };
63519     }
63520   }
63521   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63522   return jresult;
63523 }
63524
63525
63526 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetStyleName(void * jarg1, char * jarg2) {
63527   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63528   std::string *arg2 = 0 ;
63529
63530   arg1 = (Dali::Toolkit::Control *)jarg1;
63531   if (!jarg2) {
63532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63533     return ;
63534   }
63535   std::string arg2_str(jarg2);
63536   arg2 = &arg2_str;
63537   {
63538     try {
63539       (arg1)->SetStyleName((std::string const &)*arg2);
63540     } catch (std::out_of_range& e) {
63541       {
63542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (std::exception& e) {
63545       {
63546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63547       };
63548     } catch (...) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63551       };
63552     }
63553   }
63554
63555   //argout typemap for const std::string&
63556
63557 }
63558
63559
63560 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_View_GetStyleName(void * jarg1) {
63561   char * jresult ;
63562   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63563   std::string *result = 0 ;
63564
63565   arg1 = (Dali::Toolkit::Control *)jarg1;
63566   {
63567     try {
63568       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63569     } catch (std::out_of_range& e) {
63570       {
63571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63572       };
63573     } catch (std::exception& e) {
63574       {
63575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63576       };
63577     } catch (...) {
63578       {
63579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63580       };
63581     }
63582   }
63583   jresult = SWIG_csharp_string_callback(result->c_str());
63584   return jresult;
63585 }
63586
63587
63588 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63589   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63590   Dali::Vector4 *arg2 = 0 ;
63591
63592   arg1 = (Dali::Toolkit::Control *)jarg1;
63593   arg2 = (Dali::Vector4 *)jarg2;
63594   if (!arg2) {
63595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63596     return ;
63597   }
63598   {
63599     try {
63600       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63601     } catch (std::out_of_range& e) {
63602       {
63603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63604       };
63605     } catch (std::exception& e) {
63606       {
63607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63608       };
63609     } catch (...) {
63610       {
63611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63612       };
63613     }
63614   }
63615 }
63616
63617
63618 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_GetBackgroundColor(void * jarg1) {
63619   void * jresult ;
63620   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63621   Dali::Vector4 result;
63622
63623   arg1 = (Dali::Toolkit::Control *)jarg1;
63624   {
63625     try {
63626       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63627     } catch (std::out_of_range& e) {
63628       {
63629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (std::exception& e) {
63632       {
63633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63634       };
63635     } catch (...) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63638       };
63639     }
63640   }
63641   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63642   return jresult;
63643 }
63644
63645
63646 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63647   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63648   Dali::Image arg2 ;
63649   Dali::Image *argp2 ;
63650
63651   arg1 = (Dali::Toolkit::Control *)jarg1;
63652   argp2 = (Dali::Image *)jarg2;
63653   if (!argp2) {
63654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63655     return ;
63656   }
63657   arg2 = *argp2;
63658   {
63659     try {
63660       (arg1)->SetBackgroundImage(arg2);
63661     } catch (std::out_of_range& e) {
63662       {
63663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63664       };
63665     } catch (std::exception& e) {
63666       {
63667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63668       };
63669     } catch (...) {
63670       {
63671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63672       };
63673     }
63674   }
63675 }
63676
63677
63678 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_View_ClearBackground(void * jarg1) {
63679   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63680
63681   arg1 = (Dali::Toolkit::Control *)jarg1;
63682   {
63683     try {
63684       (arg1)->ClearBackground();
63685     } catch (std::out_of_range& e) {
63686       {
63687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63688       };
63689     } catch (std::exception& e) {
63690       {
63691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63692       };
63693     } catch (...) {
63694       {
63695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63696       };
63697     }
63698   }
63699 }
63700
63701
63702 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyEventSignal(void * jarg1) {
63703   void * jresult ;
63704   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63705   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63706
63707   arg1 = (Dali::Toolkit::Control *)jarg1;
63708   {
63709     try {
63710       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63711     } catch (std::out_of_range& e) {
63712       {
63713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63714       };
63715     } catch (std::exception& e) {
63716       {
63717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63718       };
63719     } catch (...) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63722       };
63723     }
63724   }
63725   jresult = (void *)result;
63726   return jresult;
63727 }
63728
63729
63730 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyInputFocusGainedSignal(void * jarg1) {
63731   void * jresult ;
63732   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63733   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63734
63735   arg1 = (Dali::Toolkit::Control *)jarg1;
63736   {
63737     try {
63738       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63746       };
63747     } catch (...) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63750       };
63751     }
63752   }
63753   jresult = (void *)result;
63754   return jresult;
63755 }
63756
63757
63758 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_View_KeyInputFocusLostSignal(void * jarg1) {
63759   void * jresult ;
63760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63761   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63762
63763   arg1 = (Dali::Toolkit::Control *)jarg1;
63764   {
63765     try {
63766       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63767     } catch (std::out_of_range& e) {
63768       {
63769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (std::exception& e) {
63772       {
63773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781   jresult = (void *)result;
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_View__SWIG_2(void * jarg1) {
63787   void * jresult ;
63788   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63789   Dali::Toolkit::Control *result = 0 ;
63790
63791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63792   if (!arg1) {
63793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63794     return 0;
63795   }
63796   {
63797     try {
63798       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63799     } catch (std::out_of_range& e) {
63800       {
63801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63802       };
63803     } catch (std::exception& e) {
63804       {
63805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63806       };
63807     } catch (...) {
63808       {
63809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63810       };
63811     }
63812   }
63813   jresult = (void *)result;
63814   return jresult;
63815 }
63816
63817
63818 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyInputFocusManager() {
63819   void * jresult ;
63820   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63821
63822   {
63823     try {
63824       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63825     } catch (std::out_of_range& e) {
63826       {
63827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63828       };
63829     } catch (std::exception& e) {
63830       {
63831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63832       };
63833     } catch (...) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63836       };
63837     }
63838   }
63839   jresult = (void *)result;
63840   return jresult;
63841 }
63842
63843
63844 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyInputFocusManager(void * jarg1) {
63845   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63846
63847   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63848   {
63849     try {
63850       delete arg1;
63851     } catch (std::out_of_range& e) {
63852       {
63853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63854       };
63855     } catch (std::exception& e) {
63856       {
63857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63862       };
63863     }
63864   }
63865 }
63866
63867
63868 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_Get() {
63869   void * jresult ;
63870   Dali::Toolkit::KeyInputFocusManager result;
63871
63872   {
63873     try {
63874       result = Dali::Toolkit::KeyInputFocusManager::Get();
63875     } catch (std::out_of_range& e) {
63876       {
63877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63878       };
63879     } catch (std::exception& e) {
63880       {
63881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63882       };
63883     } catch (...) {
63884       {
63885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63886       };
63887     }
63888   }
63889   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63890   return jresult;
63891 }
63892
63893
63894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63895   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63896   Dali::Toolkit::Control arg2 ;
63897   Dali::Toolkit::Control *argp2 ;
63898
63899   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63900   argp2 = (Dali::Toolkit::Control *)jarg2;
63901   if (!argp2) {
63902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63903     return ;
63904   }
63905   arg2 = *argp2;
63906   {
63907     try {
63908       (arg1)->SetFocus(arg2);
63909     } catch (std::out_of_range& e) {
63910       {
63911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63912       };
63913     } catch (std::exception& e) {
63914       {
63915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63916       };
63917     } catch (...) {
63918       {
63919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63920       };
63921     }
63922   }
63923 }
63924
63925
63926 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63927   void * jresult ;
63928   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63929   Dali::Toolkit::Control result;
63930
63931   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63932   {
63933     try {
63934       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63935     } catch (std::out_of_range& e) {
63936       {
63937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63938       };
63939     } catch (std::exception& e) {
63940       {
63941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63942       };
63943     } catch (...) {
63944       {
63945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63946       };
63947     }
63948   }
63949   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63950   return jresult;
63951 }
63952
63953
63954 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63955   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63956   Dali::Toolkit::Control arg2 ;
63957   Dali::Toolkit::Control *argp2 ;
63958
63959   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63960   argp2 = (Dali::Toolkit::Control *)jarg2;
63961   if (!argp2) {
63962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63963     return ;
63964   }
63965   arg2 = *argp2;
63966   {
63967     try {
63968       (arg1)->RemoveFocus(arg2);
63969     } catch (std::out_of_range& e) {
63970       {
63971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63972       };
63973     } catch (std::exception& e) {
63974       {
63975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63980       };
63981     }
63982   }
63983 }
63984
63985
63986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
63987   unsigned int jresult ;
63988   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63989   Dali::Toolkit::Control arg2 ;
63990   Dali::Toolkit::Control *argp2 ;
63991   bool result;
63992
63993   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63994   argp2 = (Dali::Toolkit::Control *)jarg2;
63995   if (!argp2) {
63996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63997     return 0;
63998   }
63999   arg2 = *argp2;
64000   {
64001     try {
64002       result = (bool)(arg1)->IsKeyboardListener(arg2);
64003     } catch (std::out_of_range& e) {
64004       {
64005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64006       };
64007     } catch (std::exception& e) {
64008       {
64009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64010       };
64011     } catch (...) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64014       };
64015     }
64016   }
64017   jresult = result;
64018   return jresult;
64019 }
64020
64021
64022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64023   void * jresult ;
64024   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64025   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64026
64027   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64028   {
64029     try {
64030       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64031     } catch (std::out_of_range& e) {
64032       {
64033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64034       };
64035     } catch (std::exception& e) {
64036       {
64037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64038       };
64039     } catch (...) {
64040       {
64041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64042       };
64043     }
64044   }
64045   jresult = (void *)result;
64046   return jresult;
64047 }
64048
64049
64050 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
64051   void * jresult ;
64052   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64053   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
64054
64055   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64056   {
64057     try {
64058       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
64059     } catch (std::out_of_range& e) {
64060       {
64061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (std::exception& e) {
64064       {
64065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (...) {
64068       {
64069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64070       };
64071     }
64072   }
64073   jresult = (void *)result;
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment_Padding__SWIG_0() {
64079   void * jresult ;
64080   Dali::Toolkit::Alignment::Padding *result = 0 ;
64081
64082   {
64083     try {
64084       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64096       };
64097     }
64098   }
64099   jresult = (void *)result;
64100   return jresult;
64101 }
64102
64103
64104 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64105   void * jresult ;
64106   float arg1 ;
64107   float arg2 ;
64108   float arg3 ;
64109   float arg4 ;
64110   Dali::Toolkit::Alignment::Padding *result = 0 ;
64111
64112   arg1 = (float)jarg1;
64113   arg2 = (float)jarg2;
64114   arg3 = (float)jarg3;
64115   arg4 = (float)jarg4;
64116   {
64117     try {
64118       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64119     } catch (std::out_of_range& e) {
64120       {
64121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64122       };
64123     } catch (std::exception& e) {
64124       {
64125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (...) {
64128       {
64129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64130       };
64131     }
64132   }
64133   jresult = (void *)result;
64134   return jresult;
64135 }
64136
64137
64138 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64139   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64140   float arg2 ;
64141
64142   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64143   arg2 = (float)jarg2;
64144   if (arg1) (arg1)->left = arg2;
64145 }
64146
64147
64148 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_left_get(void * jarg1) {
64149   float jresult ;
64150   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64151   float result;
64152
64153   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64154   result = (float) ((arg1)->left);
64155   jresult = result;
64156   return jresult;
64157 }
64158
64159
64160 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64161   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64162   float arg2 ;
64163
64164   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64165   arg2 = (float)jarg2;
64166   if (arg1) (arg1)->right = arg2;
64167 }
64168
64169
64170 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_right_get(void * jarg1) {
64171   float jresult ;
64172   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64173   float result;
64174
64175   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64176   result = (float) ((arg1)->right);
64177   jresult = result;
64178   return jresult;
64179 }
64180
64181
64182 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64183   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64184   float arg2 ;
64185
64186   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64187   arg2 = (float)jarg2;
64188   if (arg1) (arg1)->top = arg2;
64189 }
64190
64191
64192 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_top_get(void * jarg1) {
64193   float jresult ;
64194   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64195   float result;
64196
64197   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64198   result = (float) ((arg1)->top);
64199   jresult = result;
64200   return jresult;
64201 }
64202
64203
64204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64205   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64206   float arg2 ;
64207
64208   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64209   arg2 = (float)jarg2;
64210   if (arg1) (arg1)->bottom = arg2;
64211 }
64212
64213
64214 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Alignment_Padding_bottom_get(void * jarg1) {
64215   float jresult ;
64216   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64217   float result;
64218
64219   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64220   result = (float) ((arg1)->bottom);
64221   jresult = result;
64222   return jresult;
64223 }
64224
64225
64226 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Alignment_Padding(void * jarg1) {
64227   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64228
64229   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64230   {
64231     try {
64232       delete arg1;
64233     } catch (std::out_of_range& e) {
64234       {
64235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64236       };
64237     } catch (std::exception& e) {
64238       {
64239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64240       };
64241     } catch (...) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64244       };
64245     }
64246   }
64247 }
64248
64249
64250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment__SWIG_0() {
64251   void * jresult ;
64252   Dali::Toolkit::Alignment *result = 0 ;
64253
64254   {
64255     try {
64256       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64257     } catch (std::out_of_range& e) {
64258       {
64259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64260       };
64261     } catch (std::exception& e) {
64262       {
64263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64264       };
64265     } catch (...) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64268       };
64269     }
64270   }
64271   jresult = (void *)result;
64272   return jresult;
64273 }
64274
64275
64276 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64277   void * jresult ;
64278   Dali::Toolkit::Alignment::Type arg1 ;
64279   Dali::Toolkit::Alignment::Type arg2 ;
64280   Dali::Toolkit::Alignment result;
64281
64282   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64283   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64284   {
64285     try {
64286       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64287     } catch (std::out_of_range& e) {
64288       {
64289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64290       };
64291     } catch (std::exception& e) {
64292       {
64293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64294       };
64295     } catch (...) {
64296       {
64297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64298       };
64299     }
64300   }
64301   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64302   return jresult;
64303 }
64304
64305
64306 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_1(int jarg1) {
64307   void * jresult ;
64308   Dali::Toolkit::Alignment::Type arg1 ;
64309   Dali::Toolkit::Alignment result;
64310
64311   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64312   {
64313     try {
64314       result = Dali::Toolkit::Alignment::New(arg1);
64315     } catch (std::out_of_range& e) {
64316       {
64317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64318       };
64319     } catch (std::exception& e) {
64320       {
64321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (...) {
64324       {
64325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64326       };
64327     }
64328   }
64329   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64330   return jresult;
64331 }
64332
64333
64334 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_New__SWIG_2() {
64335   void * jresult ;
64336   Dali::Toolkit::Alignment result;
64337
64338   {
64339     try {
64340       result = Dali::Toolkit::Alignment::New();
64341     } catch (std::out_of_range& e) {
64342       {
64343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64344       };
64345     } catch (std::exception& e) {
64346       {
64347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64352       };
64353     }
64354   }
64355   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64356   return jresult;
64357 }
64358
64359
64360 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Alignment__SWIG_1(void * jarg1) {
64361   void * jresult ;
64362   Dali::Toolkit::Alignment *arg1 = 0 ;
64363   Dali::Toolkit::Alignment *result = 0 ;
64364
64365   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64366   if (!arg1) {
64367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64368     return 0;
64369   }
64370   {
64371     try {
64372       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64373     } catch (std::out_of_range& e) {
64374       {
64375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64376       };
64377     } catch (std::exception& e) {
64378       {
64379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64380       };
64381     } catch (...) {
64382       {
64383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64384       };
64385     }
64386   }
64387   jresult = (void *)result;
64388   return jresult;
64389 }
64390
64391
64392 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Alignment(void * jarg1) {
64393   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64394
64395   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64396   {
64397     try {
64398       delete arg1;
64399     } catch (std::out_of_range& e) {
64400       {
64401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64402       };
64403     } catch (std::exception& e) {
64404       {
64405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64406       };
64407     } catch (...) {
64408       {
64409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64410       };
64411     }
64412   }
64413 }
64414
64415
64416 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_DownCast(void * jarg1) {
64417   void * jresult ;
64418   Dali::BaseHandle arg1 ;
64419   Dali::BaseHandle *argp1 ;
64420   Dali::Toolkit::Alignment result;
64421
64422   argp1 = (Dali::BaseHandle *)jarg1;
64423   if (!argp1) {
64424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64425     return 0;
64426   }
64427   arg1 = *argp1;
64428   {
64429     try {
64430       result = Dali::Toolkit::Alignment::DownCast(arg1);
64431     } catch (std::out_of_range& e) {
64432       {
64433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64434       };
64435     } catch (std::exception& e) {
64436       {
64437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64438       };
64439     } catch (...) {
64440       {
64441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64442       };
64443     }
64444   }
64445   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64446   return jresult;
64447 }
64448
64449
64450 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64451   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64452   Dali::Toolkit::Alignment::Type arg2 ;
64453
64454   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64455   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64456   {
64457     try {
64458       (arg1)->SetAlignmentType(arg2);
64459     } catch (std::out_of_range& e) {
64460       {
64461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64462       };
64463     } catch (std::exception& e) {
64464       {
64465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64466       };
64467     } catch (...) {
64468       {
64469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64470       };
64471     }
64472   }
64473 }
64474
64475
64476 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Alignment_GetAlignmentType(void * jarg1) {
64477   int jresult ;
64478   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64479   Dali::Toolkit::Alignment::Type result;
64480
64481   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64482   {
64483     try {
64484       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64485     } catch (std::out_of_range& e) {
64486       {
64487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64488       };
64489     } catch (std::exception& e) {
64490       {
64491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64492       };
64493     } catch (...) {
64494       {
64495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64496       };
64497     }
64498   }
64499   jresult = (int)result;
64500   return jresult;
64501 }
64502
64503
64504 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetScaling(void * jarg1, int jarg2) {
64505   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64506   Dali::Toolkit::Alignment::Scaling arg2 ;
64507
64508   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64509   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64510   {
64511     try {
64512       (arg1)->SetScaling(arg2);
64513     } catch (std::out_of_range& e) {
64514       {
64515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64516       };
64517     } catch (std::exception& e) {
64518       {
64519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64520       };
64521     } catch (...) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64524       };
64525     }
64526   }
64527 }
64528
64529
64530 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Alignment_GetScaling(void * jarg1) {
64531   int jresult ;
64532   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64533   Dali::Toolkit::Alignment::Scaling result;
64534
64535   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64536   {
64537     try {
64538       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64539     } catch (std::out_of_range& e) {
64540       {
64541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64542       };
64543     } catch (std::exception& e) {
64544       {
64545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64546       };
64547     } catch (...) {
64548       {
64549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64550       };
64551     }
64552   }
64553   jresult = (int)result;
64554   return jresult;
64555 }
64556
64557
64558 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Alignment_SetPadding(void * jarg1, void * jarg2) {
64559   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64560   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64561
64562   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64563   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64564   if (!arg2) {
64565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64566     return ;
64567   }
64568   {
64569     try {
64570       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64571     } catch (std::out_of_range& e) {
64572       {
64573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64574       };
64575     } catch (std::exception& e) {
64576       {
64577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64578       };
64579     } catch (...) {
64580       {
64581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64582       };
64583     }
64584   }
64585 }
64586
64587
64588 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_GetPadding(void * jarg1) {
64589   void * jresult ;
64590   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64591   Dali::Toolkit::Alignment::Padding *result = 0 ;
64592
64593   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64594   {
64595     try {
64596       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64597     } catch (std::out_of_range& e) {
64598       {
64599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64600       };
64601     } catch (std::exception& e) {
64602       {
64603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64604       };
64605     } catch (...) {
64606       {
64607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64608       };
64609     }
64610   }
64611   jresult = (void *)result;
64612   return jresult;
64613 }
64614
64615
64616 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Alignment_Assign(void * jarg1, void * jarg2) {
64617   void * jresult ;
64618   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64619   Dali::Toolkit::Alignment *arg2 = 0 ;
64620   Dali::Toolkit::Alignment *result = 0 ;
64621
64622   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64623   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64624   if (!arg2) {
64625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64626     return 0;
64627   }
64628   {
64629     try {
64630       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64631     } catch (std::out_of_range& e) {
64632       {
64633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64634       };
64635     } catch (std::exception& e) {
64636       {
64637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64638       };
64639     } catch (...) {
64640       {
64641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64642       };
64643     }
64644   }
64645   jresult = (void *)result;
64646   return jresult;
64647 }
64648
64649
64650 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_DISABLED_get() {
64651   int jresult ;
64652   int result;
64653
64654   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64655   jresult = (int)result;
64656   return jresult;
64657 }
64658
64659
64660 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_AUTO_REPEATING_get() {
64661   int jresult ;
64662   int result;
64663
64664   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64665   jresult = (int)result;
64666   return jresult;
64667 }
64668
64669
64670 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64671   int jresult ;
64672   int result;
64673
64674   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64675   jresult = (int)result;
64676   return jresult;
64677 }
64678
64679
64680 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64681   int jresult ;
64682   int result;
64683
64684   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64685   jresult = (int)result;
64686   return jresult;
64687 }
64688
64689
64690 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_TOGGLABLE_get() {
64691   int jresult ;
64692   int result;
64693
64694   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64695   jresult = (int)result;
64696   return jresult;
64697 }
64698
64699
64700 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_get() {
64701   int jresult ;
64702   int result;
64703
64704   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64705   jresult = (int)result;
64706   return jresult;
64707 }
64708
64709
64710 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_UNSELECTED_STATE_IMAGE_get() {
64711   int jresult ;
64712   int result;
64713
64714   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
64715   jresult = (int)result;
64716   return jresult;
64717 }
64718
64719
64720 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_STATE_IMAGE_get() {
64721   int jresult ;
64722   int result;
64723
64724   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
64725   jresult = (int)result;
64726   return jresult;
64727 }
64728
64729
64730 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_DISABLED_STATE_IMAGE_get() {
64731   int jresult ;
64732   int result;
64733
64734   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
64735   jresult = (int)result;
64736   return jresult;
64737 }
64738
64739
64740 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_UNSELECTED_COLOR_get() {
64741   int jresult ;
64742   int result;
64743
64744   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64745   jresult = (int)result;
64746   return jresult;
64747 }
64748
64749
64750 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_SELECTED_COLOR_get() {
64751   int jresult ;
64752   int result;
64753
64754   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64755   jresult = (int)result;
64756   return jresult;
64757 }
64758
64759
64760 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_LABEL_get() {
64761   int jresult ;
64762   int result;
64763
64764   result = (int)Dali::Toolkit::Button::Property::LABEL;
64765   jresult = (int)result;
64766   return jresult;
64767 }
64768
64769
64770 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Button_Property_LABEL_TEXT_get() {
64771   int jresult ;
64772   int result;
64773
64774   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64775   jresult = (int)result;
64776   return jresult;
64777 }
64778
64779
64780 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button_Property() {
64781   void * jresult ;
64782   Dali::Toolkit::Button::Property *result = 0 ;
64783
64784   {
64785     try {
64786       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64787     } catch (std::out_of_range& e) {
64788       {
64789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64790       };
64791     } catch (std::exception& e) {
64792       {
64793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64794       };
64795     } catch (...) {
64796       {
64797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64798       };
64799     }
64800   }
64801   jresult = (void *)result;
64802   return jresult;
64803 }
64804
64805
64806 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Button_Property(void * jarg1) {
64807   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64808
64809   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64810   {
64811     try {
64812       delete arg1;
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64824       };
64825     }
64826   }
64827 }
64828
64829
64830 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button__SWIG_0() {
64831   void * jresult ;
64832   Dali::Toolkit::Button *result = 0 ;
64833
64834   {
64835     try {
64836       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64837     } catch (std::out_of_range& e) {
64838       {
64839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64840       };
64841     } catch (std::exception& e) {
64842       {
64843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64844       };
64845     } catch (...) {
64846       {
64847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64848       };
64849     }
64850   }
64851   jresult = (void *)result;
64852   return jresult;
64853 }
64854
64855
64856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Button__SWIG_1(void * jarg1) {
64857   void * jresult ;
64858   Dali::Toolkit::Button *arg1 = 0 ;
64859   Dali::Toolkit::Button *result = 0 ;
64860
64861   arg1 = (Dali::Toolkit::Button *)jarg1;
64862   if (!arg1) {
64863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64864     return 0;
64865   }
64866   {
64867     try {
64868       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64869     } catch (std::out_of_range& e) {
64870       {
64871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (std::exception& e) {
64874       {
64875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64876       };
64877     } catch (...) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64880       };
64881     }
64882   }
64883   jresult = (void *)result;
64884   return jresult;
64885 }
64886
64887
64888 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_Assign(void * jarg1, void * jarg2) {
64889   void * jresult ;
64890   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64891   Dali::Toolkit::Button *arg2 = 0 ;
64892   Dali::Toolkit::Button *result = 0 ;
64893
64894   arg1 = (Dali::Toolkit::Button *)jarg1;
64895   arg2 = (Dali::Toolkit::Button *)jarg2;
64896   if (!arg2) {
64897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64898     return 0;
64899   }
64900   {
64901     try {
64902       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64903     } catch (std::out_of_range& e) {
64904       {
64905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64906       };
64907     } catch (std::exception& e) {
64908       {
64909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64910       };
64911     } catch (...) {
64912       {
64913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64914       };
64915     }
64916   }
64917   jresult = (void *)result;
64918   return jresult;
64919 }
64920
64921
64922 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_DownCast(void * jarg1) {
64923   void * jresult ;
64924   Dali::BaseHandle arg1 ;
64925   Dali::BaseHandle *argp1 ;
64926   Dali::Toolkit::Button result;
64927
64928   argp1 = (Dali::BaseHandle *)jarg1;
64929   if (!argp1) {
64930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64931     return 0;
64932   }
64933   arg1 = *argp1;
64934   {
64935     try {
64936       result = Dali::Toolkit::Button::DownCast(arg1);
64937     } catch (std::out_of_range& e) {
64938       {
64939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64940       };
64941     } catch (std::exception& e) {
64942       {
64943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64944       };
64945     } catch (...) {
64946       {
64947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64948       };
64949     }
64950   }
64951   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64952   return jresult;
64953 }
64954
64955
64956 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Button(void * jarg1) {
64957   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64958
64959   arg1 = (Dali::Toolkit::Button *)jarg1;
64960   {
64961     try {
64962       delete arg1;
64963     } catch (std::out_of_range& e) {
64964       {
64965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64966       };
64967     } catch (std::exception& e) {
64968       {
64969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64970       };
64971     } catch (...) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64974       };
64975     }
64976   }
64977 }
64978
64979
64980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsDisabled(void * jarg1) {
64981   unsigned int jresult ;
64982   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64983   bool result;
64984
64985   arg1 = (Dali::Toolkit::Button *)jarg1;
64986   {
64987     try {
64988       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64989     } catch (std::out_of_range& e) {
64990       {
64991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64992       };
64993     } catch (std::exception& e) {
64994       {
64995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64996       };
64997     } catch (...) {
64998       {
64999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65000       };
65001     }
65002   }
65003   jresult = result;
65004   return jresult;
65005 }
65006
65007
65008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsAutoRepeating(void * jarg1) {
65009   unsigned int jresult ;
65010   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65011   bool result;
65012
65013   arg1 = (Dali::Toolkit::Button *)jarg1;
65014   {
65015     try {
65016       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65017     } catch (std::out_of_range& e) {
65018       {
65019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65020       };
65021     } catch (std::exception& e) {
65022       {
65023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65024       };
65025     } catch (...) {
65026       {
65027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65028       };
65029     }
65030   }
65031   jresult = result;
65032   return jresult;
65033 }
65034
65035
65036 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65037   float jresult ;
65038   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65039   float result;
65040
65041   arg1 = (Dali::Toolkit::Button *)jarg1;
65042   {
65043     try {
65044       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (...) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65056       };
65057     }
65058   }
65059   jresult = result;
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65065   float jresult ;
65066   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65067   float result;
65068
65069   arg1 = (Dali::Toolkit::Button *)jarg1;
65070   {
65071     try {
65072       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65073     } catch (std::out_of_range& e) {
65074       {
65075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65076       };
65077     } catch (std::exception& e) {
65078       {
65079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (...) {
65082       {
65083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65084       };
65085     }
65086   }
65087   jresult = result;
65088   return jresult;
65089 }
65090
65091
65092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsTogglableButton(void * jarg1) {
65093   unsigned int jresult ;
65094   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65095   bool result;
65096
65097   arg1 = (Dali::Toolkit::Button *)jarg1;
65098   {
65099     try {
65100       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65101     } catch (std::out_of_range& e) {
65102       {
65103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65104       };
65105     } catch (std::exception& e) {
65106       {
65107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65108       };
65109     } catch (...) {
65110       {
65111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65112       };
65113     }
65114   }
65115   jresult = result;
65116   return jresult;
65117 }
65118
65119
65120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Button_IsSelected(void * jarg1) {
65121   unsigned int jresult ;
65122   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65123   bool result;
65124
65125   arg1 = (Dali::Toolkit::Button *)jarg1;
65126   {
65127     try {
65128       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65129     } catch (std::out_of_range& e) {
65130       {
65131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65132       };
65133     } catch (std::exception& e) {
65134       {
65135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65136       };
65137     } catch (...) {
65138       {
65139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65140       };
65141     }
65142   }
65143   jresult = result;
65144   return jresult;
65145 }
65146
65147
65148 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Button_GetAnimationTime(void * jarg1) {
65149   float jresult ;
65150   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65151   float result;
65152
65153   arg1 = (Dali::Toolkit::Button *)jarg1;
65154   {
65155     try {
65156       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65157     } catch (std::out_of_range& e) {
65158       {
65159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65160       };
65161     } catch (std::exception& e) {
65162       {
65163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65164       };
65165     } catch (...) {
65166       {
65167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65168       };
65169     }
65170   }
65171   jresult = result;
65172   return jresult;
65173 }
65174
65175
65176 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_Button_GetLabelText(void * jarg1) {
65177   char * jresult ;
65178   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65179   std::string result;
65180
65181   arg1 = (Dali::Toolkit::Button *)jarg1;
65182   {
65183     try {
65184       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65185     } catch (std::out_of_range& e) {
65186       {
65187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65188       };
65189     } catch (std::exception& e) {
65190       {
65191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65192       };
65193     } catch (...) {
65194       {
65195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65196       };
65197     }
65198   }
65199   jresult = SWIG_csharp_string_callback((&result)->c_str());
65200   return jresult;
65201 }
65202
65203
65204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetLabel(void * jarg1, void * jarg2) {
65205   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65206   Dali::Actor arg2 ;
65207   Dali::Actor *argp2 ;
65208
65209   arg1 = (Dali::Toolkit::Button *)jarg1;
65210   argp2 = (Dali::Actor *)jarg2;
65211   if (!argp2) {
65212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65213     return ;
65214   }
65215   arg2 = *argp2;
65216   {
65217     try {
65218       (arg1)->SetLabel(arg2);
65219     } catch (std::out_of_range& e) {
65220       {
65221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65222       };
65223     } catch (std::exception& e) {
65224       {
65225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65226       };
65227     } catch (...) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65230       };
65231     }
65232   }
65233 }
65234
65235
65236 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetButtonImage(void * jarg1, void * jarg2) {
65237   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65238   Dali::Image arg2 ;
65239   Dali::Image *argp2 ;
65240
65241   arg1 = (Dali::Toolkit::Button *)jarg1;
65242   argp2 = (Dali::Image *)jarg2;
65243   if (!argp2) {
65244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65245     return ;
65246   }
65247   arg2 = *argp2;
65248   {
65249     try {
65250       (arg1)->SetButtonImage(arg2);
65251     } catch (std::out_of_range& e) {
65252       {
65253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65254       };
65255     } catch (std::exception& e) {
65256       {
65257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65258       };
65259     } catch (...) {
65260       {
65261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65262       };
65263     }
65264   }
65265 }
65266
65267
65268 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65269   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65270   Dali::Image arg2 ;
65271   Dali::Image *argp2 ;
65272
65273   arg1 = (Dali::Toolkit::Button *)jarg1;
65274   argp2 = (Dali::Image *)jarg2;
65275   if (!argp2) {
65276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65277     return ;
65278   }
65279   arg2 = *argp2;
65280   {
65281     try {
65282       (arg1)->SetSelectedImage(arg2);
65283     } catch (std::out_of_range& e) {
65284       {
65285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65286       };
65287     } catch (std::exception& e) {
65288       {
65289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65290       };
65291     } catch (...) {
65292       {
65293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65294       };
65295     }
65296   }
65297 }
65298
65299
65300 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_GetButtonImage(void * jarg1) {
65301   void * jresult ;
65302   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65303   Dali::Actor result;
65304
65305   arg1 = (Dali::Toolkit::Button *)jarg1;
65306   {
65307     try {
65308       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65309     } catch (std::out_of_range& e) {
65310       {
65311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (std::exception& e) {
65314       {
65315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65316       };
65317     } catch (...) {
65318       {
65319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65320       };
65321     }
65322   }
65323   jresult = new Dali::Actor((const Dali::Actor &)result);
65324   return jresult;
65325 }
65326
65327
65328 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_GetSelectedImage(void * jarg1) {
65329   void * jresult ;
65330   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65331   Dali::Actor result;
65332
65333   arg1 = (Dali::Toolkit::Button *)jarg1;
65334   {
65335     try {
65336       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65337     } catch (std::out_of_range& e) {
65338       {
65339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65340       };
65341     } catch (std::exception& e) {
65342       {
65343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65344       };
65345     } catch (...) {
65346       {
65347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65348       };
65349     }
65350   }
65351   jresult = new Dali::Actor((const Dali::Actor &)result);
65352   return jresult;
65353 }
65354
65355
65356 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_PressedSignal(void * jarg1) {
65357   void * jresult ;
65358   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65359   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65360
65361   arg1 = (Dali::Toolkit::Button *)jarg1;
65362   {
65363     try {
65364       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65365     } catch (std::out_of_range& e) {
65366       {
65367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (std::exception& e) {
65370       {
65371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65376       };
65377     }
65378   }
65379   jresult = (void *)result;
65380   return jresult;
65381 }
65382
65383
65384 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_ReleasedSignal(void * jarg1) {
65385   void * jresult ;
65386   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65387   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65388
65389   arg1 = (Dali::Toolkit::Button *)jarg1;
65390   {
65391     try {
65392       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65393     } catch (std::out_of_range& e) {
65394       {
65395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (std::exception& e) {
65398       {
65399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407   jresult = (void *)result;
65408   return jresult;
65409 }
65410
65411
65412 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_ClickedSignal(void * jarg1) {
65413   void * jresult ;
65414   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65415   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65416
65417   arg1 = (Dali::Toolkit::Button *)jarg1;
65418   {
65419     try {
65420       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65421     } catch (std::out_of_range& e) {
65422       {
65423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65424       };
65425     } catch (std::exception& e) {
65426       {
65427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65428       };
65429     } catch (...) {
65430       {
65431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65432       };
65433     }
65434   }
65435   jresult = (void *)result;
65436   return jresult;
65437 }
65438
65439
65440 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Button_StateChangedSignal(void * jarg1) {
65441   void * jresult ;
65442   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65443   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65444
65445   arg1 = (Dali::Toolkit::Button *)jarg1;
65446   {
65447     try {
65448       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65449     } catch (std::out_of_range& e) {
65450       {
65451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65452       };
65453     } catch (std::exception& e) {
65454       {
65455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65456       };
65457     } catch (...) {
65458       {
65459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65460       };
65461     }
65462   }
65463   jresult = (void *)result;
65464   return jresult;
65465 }
65466
65467
65468 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CheckBoxButton__SWIG_0() {
65469   void * jresult ;
65470   Dali::Toolkit::CheckBoxButton *result = 0 ;
65471
65472   {
65473     try {
65474       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65475     } catch (std::out_of_range& e) {
65476       {
65477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65478       };
65479     } catch (std::exception& e) {
65480       {
65481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65482       };
65483     } catch (...) {
65484       {
65485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65486       };
65487     }
65488   }
65489   jresult = (void *)result;
65490   return jresult;
65491 }
65492
65493
65494 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_CheckBoxButton__SWIG_1(void * jarg1) {
65495   void * jresult ;
65496   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65497   Dali::Toolkit::CheckBoxButton *result = 0 ;
65498
65499   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65500   if (!arg1) {
65501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65502     return 0;
65503   }
65504   {
65505     try {
65506       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65507     } catch (std::out_of_range& e) {
65508       {
65509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65510       };
65511     } catch (std::exception& e) {
65512       {
65513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65514       };
65515     } catch (...) {
65516       {
65517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65518       };
65519     }
65520   }
65521   jresult = (void *)result;
65522   return jresult;
65523 }
65524
65525
65526 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65527   void * jresult ;
65528   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65529   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65530   Dali::Toolkit::CheckBoxButton *result = 0 ;
65531
65532   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65533   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65534   if (!arg2) {
65535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65536     return 0;
65537   }
65538   {
65539     try {
65540       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65541     } catch (std::out_of_range& e) {
65542       {
65543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65544       };
65545     } catch (std::exception& e) {
65546       {
65547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65548       };
65549     } catch (...) {
65550       {
65551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65552       };
65553     }
65554   }
65555   jresult = (void *)result;
65556   return jresult;
65557 }
65558
65559
65560 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_CheckBoxButton(void * jarg1) {
65561   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65562
65563   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65564   {
65565     try {
65566       delete arg1;
65567     } catch (std::out_of_range& e) {
65568       {
65569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65570       };
65571     } catch (std::exception& e) {
65572       {
65573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65574       };
65575     } catch (...) {
65576       {
65577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65578       };
65579     }
65580   }
65581 }
65582
65583
65584 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_New() {
65585   void * jresult ;
65586   Dali::Toolkit::CheckBoxButton result;
65587
65588   {
65589     try {
65590       result = Dali::Toolkit::CheckBoxButton::New();
65591     } catch (std::out_of_range& e) {
65592       {
65593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65594       };
65595     } catch (std::exception& e) {
65596       {
65597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65598       };
65599     } catch (...) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65602       };
65603     }
65604   }
65605   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65606   return jresult;
65607 }
65608
65609
65610 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_CheckBoxButton_DownCast(void * jarg1) {
65611   void * jresult ;
65612   Dali::BaseHandle arg1 ;
65613   Dali::BaseHandle *argp1 ;
65614   Dali::Toolkit::CheckBoxButton result;
65615
65616   argp1 = (Dali::BaseHandle *)jarg1;
65617   if (!argp1) {
65618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65619     return 0;
65620   }
65621   arg1 = *argp1;
65622   {
65623     try {
65624       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65625     } catch (std::out_of_range& e) {
65626       {
65627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65628       };
65629     } catch (std::exception& e) {
65630       {
65631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65632       };
65633     } catch (...) {
65634       {
65635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65636       };
65637     }
65638   }
65639   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65640   return jresult;
65641 }
65642
65643
65644 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_UNSELECTED_ICON_get() {
65645   int jresult ;
65646   int result;
65647
65648   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65649   jresult = (int)result;
65650   return jresult;
65651 }
65652
65653
65654 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_SELECTED_ICON_get() {
65655   int jresult ;
65656   int result;
65657
65658   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65659   jresult = (int)result;
65660   return jresult;
65661 }
65662
65663
65664 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_ICON_ALIGNMENT_get() {
65665   int jresult ;
65666   int result;
65667
65668   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65669   jresult = (int)result;
65670   return jresult;
65671 }
65672
65673
65674 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_LABEL_PADDING_get() {
65675   int jresult ;
65676   int result;
65677
65678   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65679   jresult = (int)result;
65680   return jresult;
65681 }
65682
65683
65684 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PushButton_Property_ICON_PADDING_get() {
65685   int jresult ;
65686   int result;
65687
65688   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65689   jresult = (int)result;
65690   return jresult;
65691 }
65692
65693
65694 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton_Property() {
65695   void * jresult ;
65696   Dali::Toolkit::PushButton::Property *result = 0 ;
65697
65698   {
65699     try {
65700       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65701     } catch (std::out_of_range& e) {
65702       {
65703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65704       };
65705     } catch (std::exception& e) {
65706       {
65707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65708       };
65709     } catch (...) {
65710       {
65711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65712       };
65713     }
65714   }
65715   jresult = (void *)result;
65716   return jresult;
65717 }
65718
65719
65720 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PushButton_Property(void * jarg1) {
65721   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65722
65723   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65724   {
65725     try {
65726       delete arg1;
65727     } catch (std::out_of_range& e) {
65728       {
65729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65730       };
65731     } catch (std::exception& e) {
65732       {
65733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65734       };
65735     } catch (...) {
65736       {
65737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65738       };
65739     }
65740   }
65741 }
65742
65743
65744 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton__SWIG_0() {
65745   void * jresult ;
65746   Dali::Toolkit::PushButton *result = 0 ;
65747
65748   {
65749     try {
65750       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65751     } catch (std::out_of_range& e) {
65752       {
65753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65754       };
65755     } catch (std::exception& e) {
65756       {
65757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65758       };
65759     } catch (...) {
65760       {
65761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65762       };
65763     }
65764   }
65765   jresult = (void *)result;
65766   return jresult;
65767 }
65768
65769
65770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PushButton__SWIG_1(void * jarg1) {
65771   void * jresult ;
65772   Dali::Toolkit::PushButton *arg1 = 0 ;
65773   Dali::Toolkit::PushButton *result = 0 ;
65774
65775   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65776   if (!arg1) {
65777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65778     return 0;
65779   }
65780   {
65781     try {
65782       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65783     } catch (std::out_of_range& e) {
65784       {
65785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65786       };
65787     } catch (std::exception& e) {
65788       {
65789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65790       };
65791     } catch (...) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65794       };
65795     }
65796   }
65797   jresult = (void *)result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_Assign(void * jarg1, void * jarg2) {
65803   void * jresult ;
65804   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65805   Dali::Toolkit::PushButton *arg2 = 0 ;
65806   Dali::Toolkit::PushButton *result = 0 ;
65807
65808   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65809   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65810   if (!arg2) {
65811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65812     return 0;
65813   }
65814   {
65815     try {
65816       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65817     } catch (std::out_of_range& e) {
65818       {
65819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65820       };
65821     } catch (std::exception& e) {
65822       {
65823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65824       };
65825     } catch (...) {
65826       {
65827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65828       };
65829     }
65830   }
65831   jresult = (void *)result;
65832   return jresult;
65833 }
65834
65835
65836 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PushButton(void * jarg1) {
65837   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65838
65839   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65840   {
65841     try {
65842       delete arg1;
65843     } catch (std::out_of_range& e) {
65844       {
65845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65846       };
65847     } catch (std::exception& e) {
65848       {
65849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65850       };
65851     } catch (...) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65854       };
65855     }
65856   }
65857 }
65858
65859
65860 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_New() {
65861   void * jresult ;
65862   Dali::Toolkit::PushButton result;
65863
65864   {
65865     try {
65866       result = Dali::Toolkit::PushButton::New();
65867     } catch (std::out_of_range& e) {
65868       {
65869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65870       };
65871     } catch (std::exception& e) {
65872       {
65873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65874       };
65875     } catch (...) {
65876       {
65877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65878       };
65879     }
65880   }
65881   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65882   return jresult;
65883 }
65884
65885
65886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PushButton_DownCast(void * jarg1) {
65887   void * jresult ;
65888   Dali::BaseHandle arg1 ;
65889   Dali::BaseHandle *argp1 ;
65890   Dali::Toolkit::PushButton result;
65891
65892   argp1 = (Dali::BaseHandle *)jarg1;
65893   if (!argp1) {
65894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65895     return 0;
65896   }
65897   arg1 = *argp1;
65898   {
65899     try {
65900       result = Dali::Toolkit::PushButton::DownCast(arg1);
65901     } catch (std::out_of_range& e) {
65902       {
65903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65904       };
65905     } catch (std::exception& e) {
65906       {
65907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65908       };
65909     } catch (...) {
65910       {
65911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65912       };
65913     }
65914   }
65915   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65916   return jresult;
65917 }
65918
65919
65920 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65921   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65922   Dali::Image arg2 ;
65923   Dali::Image *argp2 ;
65924
65925   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65926   argp2 = (Dali::Image *)jarg2;
65927   if (!argp2) {
65928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65929     return ;
65930   }
65931   arg2 = *argp2;
65932   {
65933     try {
65934       (arg1)->SetButtonImage(arg2);
65935     } catch (std::out_of_range& e) {
65936       {
65937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65938       };
65939     } catch (std::exception& e) {
65940       {
65941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65942       };
65943     } catch (...) {
65944       {
65945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65946       };
65947     }
65948   }
65949 }
65950
65951
65952 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65953   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65954   Dali::Actor arg2 ;
65955   Dali::Actor *argp2 ;
65956
65957   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65958   argp2 = (Dali::Actor *)jarg2;
65959   if (!argp2) {
65960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65961     return ;
65962   }
65963   arg2 = *argp2;
65964   {
65965     try {
65966       (arg1)->SetButtonImage(arg2);
65967     } catch (std::out_of_range& e) {
65968       {
65969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65970       };
65971     } catch (std::exception& e) {
65972       {
65973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65974       };
65975     } catch (...) {
65976       {
65977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65978       };
65979     }
65980   }
65981 }
65982
65983
65984 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65985   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65986   Dali::Actor arg2 ;
65987   Dali::Actor *argp2 ;
65988
65989   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65990   argp2 = (Dali::Actor *)jarg2;
65991   if (!argp2) {
65992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65993     return ;
65994   }
65995   arg2 = *argp2;
65996   {
65997     try {
65998       (arg1)->SetBackgroundImage(arg2);
65999     } catch (std::out_of_range& e) {
66000       {
66001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66002       };
66003     } catch (std::exception& e) {
66004       {
66005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66006       };
66007     } catch (...) {
66008       {
66009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66010       };
66011     }
66012   }
66013 }
66014
66015
66016 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66017   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66018   Dali::Image arg2 ;
66019   Dali::Image *argp2 ;
66020
66021   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66022   argp2 = (Dali::Image *)jarg2;
66023   if (!argp2) {
66024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66025     return ;
66026   }
66027   arg2 = *argp2;
66028   {
66029     try {
66030       (arg1)->SetSelectedImage(arg2);
66031     } catch (std::out_of_range& e) {
66032       {
66033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66034       };
66035     } catch (std::exception& e) {
66036       {
66037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66038       };
66039     } catch (...) {
66040       {
66041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66042       };
66043     }
66044   }
66045 }
66046
66047
66048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66049   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66050   Dali::Actor arg2 ;
66051   Dali::Actor *argp2 ;
66052
66053   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66054   argp2 = (Dali::Actor *)jarg2;
66055   if (!argp2) {
66056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66057     return ;
66058   }
66059   arg2 = *argp2;
66060   {
66061     try {
66062       (arg1)->SetSelectedImage(arg2);
66063     } catch (std::out_of_range& e) {
66064       {
66065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66066       };
66067     } catch (std::exception& e) {
66068       {
66069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66070       };
66071     } catch (...) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66074       };
66075     }
66076   }
66077 }
66078
66079
66080 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66081   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66082   Dali::Actor arg2 ;
66083   Dali::Actor *argp2 ;
66084
66085   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66086   argp2 = (Dali::Actor *)jarg2;
66087   if (!argp2) {
66088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66089     return ;
66090   }
66091   arg2 = *argp2;
66092   {
66093     try {
66094       (arg1)->SetSelectedBackgroundImage(arg2);
66095     } catch (std::out_of_range& e) {
66096       {
66097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66098       };
66099     } catch (std::exception& e) {
66100       {
66101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66102       };
66103     } catch (...) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66106       };
66107     }
66108   }
66109 }
66110
66111
66112 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66113   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66114   Dali::Actor arg2 ;
66115   Dali::Actor *argp2 ;
66116
66117   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66118   argp2 = (Dali::Actor *)jarg2;
66119   if (!argp2) {
66120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66121     return ;
66122   }
66123   arg2 = *argp2;
66124   {
66125     try {
66126       (arg1)->SetDisabledBackgroundImage(arg2);
66127     } catch (std::out_of_range& e) {
66128       {
66129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66130       };
66131     } catch (std::exception& e) {
66132       {
66133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66134       };
66135     } catch (...) {
66136       {
66137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66138       };
66139     }
66140   }
66141 }
66142
66143
66144 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66145   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66146   Dali::Actor arg2 ;
66147   Dali::Actor *argp2 ;
66148
66149   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66150   argp2 = (Dali::Actor *)jarg2;
66151   if (!argp2) {
66152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66153     return ;
66154   }
66155   arg2 = *argp2;
66156   {
66157     try {
66158       (arg1)->SetDisabledImage(arg2);
66159     } catch (std::out_of_range& e) {
66160       {
66161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66162       };
66163     } catch (std::exception& e) {
66164       {
66165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66166       };
66167     } catch (...) {
66168       {
66169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66170       };
66171     }
66172   }
66173 }
66174
66175
66176 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66177   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66178   Dali::Actor arg2 ;
66179   Dali::Actor *argp2 ;
66180
66181   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66182   argp2 = (Dali::Actor *)jarg2;
66183   if (!argp2) {
66184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66185     return ;
66186   }
66187   arg2 = *argp2;
66188   {
66189     try {
66190       (arg1)->SetDisabledSelectedImage(arg2);
66191     } catch (std::out_of_range& e) {
66192       {
66193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66194       };
66195     } catch (std::exception& e) {
66196       {
66197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (...) {
66200       {
66201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66202       };
66203     }
66204   }
66205 }
66206
66207
66208 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RadioButton__SWIG_0() {
66209   void * jresult ;
66210   Dali::Toolkit::RadioButton *result = 0 ;
66211
66212   {
66213     try {
66214       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (...) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66226       };
66227     }
66228   }
66229   jresult = (void *)result;
66230   return jresult;
66231 }
66232
66233
66234 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RadioButton__SWIG_1(void * jarg1) {
66235   void * jresult ;
66236   Dali::Toolkit::RadioButton *arg1 = 0 ;
66237   Dali::Toolkit::RadioButton *result = 0 ;
66238
66239   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66240   if (!arg1) {
66241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66242     return 0;
66243   }
66244   {
66245     try {
66246       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66247     } catch (std::out_of_range& e) {
66248       {
66249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66250       };
66251     } catch (std::exception& e) {
66252       {
66253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66254       };
66255     } catch (...) {
66256       {
66257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66258       };
66259     }
66260   }
66261   jresult = (void *)result;
66262   return jresult;
66263 }
66264
66265
66266 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_Assign(void * jarg1, void * jarg2) {
66267   void * jresult ;
66268   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66269   Dali::Toolkit::RadioButton *arg2 = 0 ;
66270   Dali::Toolkit::RadioButton *result = 0 ;
66271
66272   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66273   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66274   if (!arg2) {
66275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66276     return 0;
66277   }
66278   {
66279     try {
66280       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66281     } catch (std::out_of_range& e) {
66282       {
66283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66284       };
66285     } catch (std::exception& e) {
66286       {
66287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66288       };
66289     } catch (...) {
66290       {
66291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66292       };
66293     }
66294   }
66295   jresult = (void *)result;
66296   return jresult;
66297 }
66298
66299
66300 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RadioButton(void * jarg1) {
66301   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66302
66303   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66304   {
66305     try {
66306       delete arg1;
66307     } catch (std::out_of_range& e) {
66308       {
66309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66310       };
66311     } catch (std::exception& e) {
66312       {
66313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66314       };
66315     } catch (...) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66318       };
66319     }
66320   }
66321 }
66322
66323
66324 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_New__SWIG_0() {
66325   void * jresult ;
66326   Dali::Toolkit::RadioButton result;
66327
66328   {
66329     try {
66330       result = Dali::Toolkit::RadioButton::New();
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (...) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66342       };
66343     }
66344   }
66345   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66346   return jresult;
66347 }
66348
66349
66350 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_New__SWIG_1(char * jarg1) {
66351   void * jresult ;
66352   std::string *arg1 = 0 ;
66353   Dali::Toolkit::RadioButton result;
66354
66355   if (!jarg1) {
66356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66357     return 0;
66358   }
66359   std::string arg1_str(jarg1);
66360   arg1 = &arg1_str;
66361   {
66362     try {
66363       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66364     } catch (std::out_of_range& e) {
66365       {
66366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66367       };
66368     } catch (std::exception& e) {
66369       {
66370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66371       };
66372     } catch (...) {
66373       {
66374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66375       };
66376     }
66377   }
66378   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66379
66380   //argout typemap for const std::string&
66381
66382   return jresult;
66383 }
66384
66385
66386 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RadioButton_DownCast(void * jarg1) {
66387   void * jresult ;
66388   Dali::BaseHandle arg1 ;
66389   Dali::BaseHandle *argp1 ;
66390   Dali::Toolkit::RadioButton result;
66391
66392   argp1 = (Dali::BaseHandle *)jarg1;
66393   if (!argp1) {
66394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66395     return 0;
66396   }
66397   arg1 = *argp1;
66398   {
66399     try {
66400       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66401     } catch (std::out_of_range& e) {
66402       {
66403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66404       };
66405     } catch (std::exception& e) {
66406       {
66407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66408       };
66409     } catch (...) {
66410       {
66411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66412       };
66413     }
66414   }
66415   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66416   return jresult;
66417 }
66418
66419
66420 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_CONTENT_DIRECTION_get() {
66421   int jresult ;
66422   int result;
66423
66424   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66425   jresult = (int)result;
66426   return jresult;
66427 }
66428
66429
66430 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_FLEX_DIRECTION_get() {
66431   int jresult ;
66432   int result;
66433
66434   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66435   jresult = (int)result;
66436   return jresult;
66437 }
66438
66439
66440 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_FLEX_WRAP_get() {
66441   int jresult ;
66442   int result;
66443
66444   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66445   jresult = (int)result;
66446   return jresult;
66447 }
66448
66449
66450 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66451   int jresult ;
66452   int result;
66453
66454   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66455   jresult = (int)result;
66456   return jresult;
66457 }
66458
66459
66460 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_ALIGN_ITEMS_get() {
66461   int jresult ;
66462   int result;
66463
66464   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66465   jresult = (int)result;
66466   return jresult;
66467 }
66468
66469
66470 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_Property_ALIGN_CONTENT_get() {
66471   int jresult ;
66472   int result;
66473
66474   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66475   jresult = (int)result;
66476   return jresult;
66477 }
66478
66479
66480 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer_Property() {
66481   void * jresult ;
66482   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66483
66484   {
66485     try {
66486       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66487     } catch (std::out_of_range& e) {
66488       {
66489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66490       };
66491     } catch (std::exception& e) {
66492       {
66493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66494       };
66495     } catch (...) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66498       };
66499     }
66500   }
66501   jresult = (void *)result;
66502   return jresult;
66503 }
66504
66505
66506 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FlexContainer_Property(void * jarg1) {
66507   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66508
66509   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66510   {
66511     try {
66512       delete arg1;
66513     } catch (std::out_of_range& e) {
66514       {
66515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66516       };
66517     } catch (std::exception& e) {
66518       {
66519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66520       };
66521     } catch (...) {
66522       {
66523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66524       };
66525     }
66526   }
66527 }
66528
66529
66530 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_FLEX_get() {
66531   int jresult ;
66532   int result;
66533
66534   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66535   jresult = (int)result;
66536   return jresult;
66537 }
66538
66539
66540 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66541   int jresult ;
66542   int result;
66543
66544   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66545   jresult = (int)result;
66546   return jresult;
66547 }
66548
66549
66550 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66551   int jresult ;
66552   int result;
66553
66554   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66555   jresult = (int)result;
66556   return jresult;
66557 }
66558
66559
66560 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer_ChildProperty() {
66561   void * jresult ;
66562   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66563
66564   {
66565     try {
66566       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66567     } catch (std::out_of_range& e) {
66568       {
66569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66570       };
66571     } catch (std::exception& e) {
66572       {
66573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (...) {
66576       {
66577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66578       };
66579     }
66580   }
66581   jresult = (void *)result;
66582   return jresult;
66583 }
66584
66585
66586 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FlexContainer_ChildProperty(void * jarg1) {
66587   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66588
66589   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66590   {
66591     try {
66592       delete arg1;
66593     } catch (std::out_of_range& e) {
66594       {
66595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66596       };
66597     } catch (std::exception& e) {
66598       {
66599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66600       };
66601     } catch (...) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66604       };
66605     }
66606   }
66607 }
66608
66609
66610 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer__SWIG_0() {
66611   void * jresult ;
66612   Dali::Toolkit::FlexContainer *result = 0 ;
66613
66614   {
66615     try {
66616       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66617     } catch (std::out_of_range& e) {
66618       {
66619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66620       };
66621     } catch (std::exception& e) {
66622       {
66623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66624       };
66625     } catch (...) {
66626       {
66627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66628       };
66629     }
66630   }
66631   jresult = (void *)result;
66632   return jresult;
66633 }
66634
66635
66636 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FlexContainer__SWIG_1(void * jarg1) {
66637   void * jresult ;
66638   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66639   Dali::Toolkit::FlexContainer *result = 0 ;
66640
66641   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66642   if (!arg1) {
66643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66644     return 0;
66645   }
66646   {
66647     try {
66648       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66649     } catch (std::out_of_range& e) {
66650       {
66651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66652       };
66653     } catch (std::exception& e) {
66654       {
66655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66656       };
66657     } catch (...) {
66658       {
66659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66660       };
66661     }
66662   }
66663   jresult = (void *)result;
66664   return jresult;
66665 }
66666
66667
66668 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_Assign(void * jarg1, void * jarg2) {
66669   void * jresult ;
66670   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66671   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66672   Dali::Toolkit::FlexContainer *result = 0 ;
66673
66674   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66675   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66676   if (!arg2) {
66677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66678     return 0;
66679   }
66680   {
66681     try {
66682       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66690       };
66691     } catch (...) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66694       };
66695     }
66696   }
66697   jresult = (void *)result;
66698   return jresult;
66699 }
66700
66701
66702 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FlexContainer(void * jarg1) {
66703   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66704
66705   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66706   {
66707     try {
66708       delete arg1;
66709     } catch (std::out_of_range& e) {
66710       {
66711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66712       };
66713     } catch (std::exception& e) {
66714       {
66715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66716       };
66717     } catch (...) {
66718       {
66719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66720       };
66721     }
66722   }
66723 }
66724
66725
66726 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_New() {
66727   void * jresult ;
66728   Dali::Toolkit::FlexContainer result;
66729
66730   {
66731     try {
66732       result = Dali::Toolkit::FlexContainer::New();
66733     } catch (std::out_of_range& e) {
66734       {
66735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66736       };
66737     } catch (std::exception& e) {
66738       {
66739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66740       };
66741     } catch (...) {
66742       {
66743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66744       };
66745     }
66746   }
66747   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66748   return jresult;
66749 }
66750
66751
66752 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_FlexContainer_DownCast(void * jarg1) {
66753   void * jresult ;
66754   Dali::BaseHandle arg1 ;
66755   Dali::BaseHandle *argp1 ;
66756   Dali::Toolkit::FlexContainer result;
66757
66758   argp1 = (Dali::BaseHandle *)jarg1;
66759   if (!argp1) {
66760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66761     return 0;
66762   }
66763   arg1 = *argp1;
66764   {
66765     try {
66766       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66767     } catch (std::out_of_range& e) {
66768       {
66769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66770       };
66771     } catch (std::exception& e) {
66772       {
66773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66774       };
66775     } catch (...) {
66776       {
66777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66778       };
66779     }
66780   }
66781   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66782   return jresult;
66783 }
66784
66785
66786 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_RESOURCE_URL_get() {
66787   int jresult ;
66788   int result;
66789
66790   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66791   jresult = (int)result;
66792   return jresult;
66793 }
66794
66795
66796 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_IMAGE_get() {
66797   int jresult ;
66798   int result;
66799
66800   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66801   jresult = (int)result;
66802   return jresult;
66803 }
66804
66805
66806 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66807   int jresult ;
66808   int result;
66809
66810   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66811   jresult = (int)result;
66812   return jresult;
66813 }
66814
66815
66816 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ImageView_Property_PIXEL_AREA_get() {
66817   int jresult ;
66818   int result;
66819
66820   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66821   jresult = (int)result;
66822   return jresult;
66823 }
66824
66825
66826 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView_Property() {
66827   void * jresult ;
66828   Dali::Toolkit::ImageView::Property *result = 0 ;
66829
66830   {
66831     try {
66832       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66833     } catch (std::out_of_range& e) {
66834       {
66835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66836       };
66837     } catch (std::exception& e) {
66838       {
66839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66840       };
66841     } catch (...) {
66842       {
66843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66844       };
66845     }
66846   }
66847   jresult = (void *)result;
66848   return jresult;
66849 }
66850
66851
66852 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageView_Property(void * jarg1) {
66853   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66854
66855   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66856   {
66857     try {
66858       delete arg1;
66859     } catch (std::out_of_range& e) {
66860       {
66861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66862       };
66863     } catch (std::exception& e) {
66864       {
66865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66866       };
66867     } catch (...) {
66868       {
66869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66870       };
66871     }
66872   }
66873 }
66874
66875
66876 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView__SWIG_0() {
66877   void * jresult ;
66878   Dali::Toolkit::ImageView *result = 0 ;
66879
66880   {
66881     try {
66882       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66894       };
66895     }
66896   }
66897   jresult = (void *)result;
66898   return jresult;
66899 }
66900
66901
66902 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_0() {
66903   void * jresult ;
66904   Dali::Toolkit::ImageView result;
66905
66906   {
66907     try {
66908       result = Dali::Toolkit::ImageView::New();
66909     } catch (std::out_of_range& e) {
66910       {
66911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66912       };
66913     } catch (std::exception& e) {
66914       {
66915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66916       };
66917     } catch (...) {
66918       {
66919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66920       };
66921     }
66922   }
66923   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66924   return jresult;
66925 }
66926
66927
66928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_1(void * jarg1) {
66929   void * jresult ;
66930   Dali::Image arg1 ;
66931   Dali::Image *argp1 ;
66932   Dali::Toolkit::ImageView result;
66933
66934   argp1 = (Dali::Image *)jarg1;
66935   if (!argp1) {
66936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66937     return 0;
66938   }
66939   arg1 = *argp1;
66940   {
66941     try {
66942       result = Dali::Toolkit::ImageView::New(arg1);
66943     } catch (std::out_of_range& e) {
66944       {
66945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66946       };
66947     } catch (std::exception& e) {
66948       {
66949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66950       };
66951     } catch (...) {
66952       {
66953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66954       };
66955     }
66956   }
66957   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66958   return jresult;
66959 }
66960
66961
66962 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_2(char * jarg1) {
66963   void * jresult ;
66964   std::string *arg1 = 0 ;
66965   Dali::Toolkit::ImageView result;
66966
66967   if (!jarg1) {
66968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66969     return 0;
66970   }
66971   std::string arg1_str(jarg1);
66972   arg1 = &arg1_str;
66973   {
66974     try {
66975       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66976     } catch (std::out_of_range& e) {
66977       {
66978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66979       };
66980     } catch (std::exception& e) {
66981       {
66982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66983       };
66984     } catch (...) {
66985       {
66986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66987       };
66988     }
66989   }
66990   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66991
66992   //argout typemap for const std::string&
66993
66994   return jresult;
66995 }
66996
66997
66998 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66999   void * jresult ;
67000   std::string *arg1 = 0 ;
67001   Dali::ImageDimensions arg2 ;
67002   Dali::ImageDimensions *argp2 ;
67003   Dali::Toolkit::ImageView result;
67004
67005   if (!jarg1) {
67006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67007     return 0;
67008   }
67009   std::string arg1_str(jarg1);
67010   arg1 = &arg1_str;
67011   argp2 = (Dali::ImageDimensions *)jarg2;
67012   if (!argp2) {
67013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67014     return 0;
67015   }
67016   arg2 = *argp2;
67017   {
67018     try {
67019       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67020     } catch (std::out_of_range& e) {
67021       {
67022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67023       };
67024     } catch (std::exception& e) {
67025       {
67026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67027       };
67028     } catch (...) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67031       };
67032     }
67033   }
67034   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67035
67036   //argout typemap for const std::string&
67037
67038   return jresult;
67039 }
67040
67041
67042 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ImageView(void * jarg1) {
67043   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67044
67045   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67046   {
67047     try {
67048       delete arg1;
67049     } catch (std::out_of_range& e) {
67050       {
67051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67052       };
67053     } catch (std::exception& e) {
67054       {
67055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67056       };
67057     } catch (...) {
67058       {
67059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67060       };
67061     }
67062   }
67063 }
67064
67065
67066 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ImageView__SWIG_1(void * jarg1) {
67067   void * jresult ;
67068   Dali::Toolkit::ImageView *arg1 = 0 ;
67069   Dali::Toolkit::ImageView *result = 0 ;
67070
67071   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67072   if (!arg1) {
67073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67074     return 0;
67075   }
67076   {
67077     try {
67078       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67079     } catch (std::out_of_range& e) {
67080       {
67081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67082       };
67083     } catch (std::exception& e) {
67084       {
67085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67086       };
67087     } catch (...) {
67088       {
67089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67090       };
67091     }
67092   }
67093   jresult = (void *)result;
67094   return jresult;
67095 }
67096
67097
67098 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_Assign(void * jarg1, void * jarg2) {
67099   void * jresult ;
67100   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67101   Dali::Toolkit::ImageView *arg2 = 0 ;
67102   Dali::Toolkit::ImageView *result = 0 ;
67103
67104   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67105   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67106   if (!arg2) {
67107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67108     return 0;
67109   }
67110   {
67111     try {
67112       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67113     } catch (std::out_of_range& e) {
67114       {
67115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67116       };
67117     } catch (std::exception& e) {
67118       {
67119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67120       };
67121     } catch (...) {
67122       {
67123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67124       };
67125     }
67126   }
67127   jresult = (void *)result;
67128   return jresult;
67129 }
67130
67131
67132 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_DownCast(void * jarg1) {
67133   void * jresult ;
67134   Dali::BaseHandle arg1 ;
67135   Dali::BaseHandle *argp1 ;
67136   Dali::Toolkit::ImageView result;
67137
67138   argp1 = (Dali::BaseHandle *)jarg1;
67139   if (!argp1) {
67140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67141     return 0;
67142   }
67143   arg1 = *argp1;
67144   {
67145     try {
67146       result = Dali::Toolkit::ImageView::DownCast(arg1);
67147     } catch (std::out_of_range& e) {
67148       {
67149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67150       };
67151     } catch (std::exception& e) {
67152       {
67153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67154       };
67155     } catch (...) {
67156       {
67157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67158       };
67159     }
67160   }
67161   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67162   return jresult;
67163 }
67164
67165
67166 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67167   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67168   Dali::Image arg2 ;
67169   Dali::Image *argp2 ;
67170
67171   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67172   argp2 = (Dali::Image *)jarg2;
67173   if (!argp2) {
67174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67175     return ;
67176   }
67177   arg2 = *argp2;
67178   {
67179     try {
67180       (arg1)->SetImage(arg2);
67181     } catch (std::out_of_range& e) {
67182       {
67183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67184       };
67185     } catch (std::exception& e) {
67186       {
67187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67188       };
67189     } catch (...) {
67190       {
67191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67192       };
67193     }
67194   }
67195 }
67196
67197
67198 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67199   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67200   std::string *arg2 = 0 ;
67201
67202   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67203   if (!jarg2) {
67204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67205     return ;
67206   }
67207   std::string arg2_str(jarg2);
67208   arg2 = &arg2_str;
67209   {
67210     try {
67211       (arg1)->SetImage((std::string const &)*arg2);
67212     } catch (std::out_of_range& e) {
67213       {
67214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67215       };
67216     } catch (std::exception& e) {
67217       {
67218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67219       };
67220     } catch (...) {
67221       {
67222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67223       };
67224     }
67225   }
67226
67227   //argout typemap for const std::string&
67228
67229 }
67230
67231
67232 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67233   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67234   std::string *arg2 = 0 ;
67235   Dali::ImageDimensions arg3 ;
67236   Dali::ImageDimensions *argp3 ;
67237
67238   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67239   if (!jarg2) {
67240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67241     return ;
67242   }
67243   std::string arg2_str(jarg2);
67244   arg2 = &arg2_str;
67245   argp3 = (Dali::ImageDimensions *)jarg3;
67246   if (!argp3) {
67247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67248     return ;
67249   }
67250   arg3 = *argp3;
67251   {
67252     try {
67253       (arg1)->SetImage((std::string const &)*arg2,arg3);
67254     } catch (std::out_of_range& e) {
67255       {
67256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67257       };
67258     } catch (std::exception& e) {
67259       {
67260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67261       };
67262     } catch (...) {
67263       {
67264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67265       };
67266     }
67267   }
67268
67269   //argout typemap for const std::string&
67270
67271 }
67272
67273
67274 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ImageView_GetImage(void * jarg1) {
67275   void * jresult ;
67276   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67277   Dali::Image result;
67278
67279   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67280   {
67281     try {
67282       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67283     } catch (std::out_of_range& e) {
67284       {
67285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67286       };
67287     } catch (std::exception& e) {
67288       {
67289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67294       };
67295     }
67296   }
67297   jresult = new Dali::Image((const Dali::Image &)result);
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_GEOMETRY_URL_get() {
67303   int jresult ;
67304   int result;
67305
67306   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67307   jresult = (int)result;
67308   return jresult;
67309 }
67310
67311
67312 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_MATERIAL_URL_get() {
67313   int jresult ;
67314   int result;
67315
67316   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67317   jresult = (int)result;
67318   return jresult;
67319 }
67320
67321
67322 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_IMAGES_URL_get() {
67323   int jresult ;
67324   int result;
67325
67326   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67327   jresult = (int)result;
67328   return jresult;
67329 }
67330
67331
67332 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_ILLUMINATION_TYPE_get() {
67333   int jresult ;
67334   int result;
67335
67336   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67337   jresult = (int)result;
67338   return jresult;
67339 }
67340
67341
67342 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE0_URL_get() {
67343   int jresult ;
67344   int result;
67345
67346   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67347   jresult = (int)result;
67348   return jresult;
67349 }
67350
67351
67352 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE1_URL_get() {
67353   int jresult ;
67354   int result;
67355
67356   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67357   jresult = (int)result;
67358   return jresult;
67359 }
67360
67361
67362 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_TEXTURE2_URL_get() {
67363   int jresult ;
67364   int result;
67365
67366   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67367   jresult = (int)result;
67368   return jresult;
67369 }
67370
67371
67372 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Model3dView_Property_LIGHT_POSITION_get() {
67373   int jresult ;
67374   int result;
67375
67376   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67377   jresult = (int)result;
67378   return jresult;
67379 }
67380
67381
67382 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView_Property() {
67383   void * jresult ;
67384   Dali::Toolkit::Model3dView::Property *result = 0 ;
67385
67386   {
67387     try {
67388       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67400       };
67401     }
67402   }
67403   jresult = (void *)result;
67404   return jresult;
67405 }
67406
67407
67408 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Model3dView_Property(void * jarg1) {
67409   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67410
67411   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67412   {
67413     try {
67414       delete arg1;
67415     } catch (std::out_of_range& e) {
67416       {
67417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67418       };
67419     } catch (std::exception& e) {
67420       {
67421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67422       };
67423     } catch (...) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67426       };
67427     }
67428   }
67429 }
67430
67431
67432 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_New__SWIG_0() {
67433   void * jresult ;
67434   Dali::Toolkit::Model3dView result;
67435
67436   {
67437     try {
67438       result = Dali::Toolkit::Model3dView::New();
67439     } catch (std::out_of_range& e) {
67440       {
67441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67442       };
67443     } catch (std::exception& e) {
67444       {
67445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67446       };
67447     } catch (...) {
67448       {
67449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67450       };
67451     }
67452   }
67453   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67454   return jresult;
67455 }
67456
67457
67458 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67459   void * jresult ;
67460   std::string *arg1 = 0 ;
67461   std::string *arg2 = 0 ;
67462   std::string *arg3 = 0 ;
67463   Dali::Toolkit::Model3dView result;
67464
67465   if (!jarg1) {
67466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67467     return 0;
67468   }
67469   std::string arg1_str(jarg1);
67470   arg1 = &arg1_str;
67471   if (!jarg2) {
67472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67473     return 0;
67474   }
67475   std::string arg2_str(jarg2);
67476   arg2 = &arg2_str;
67477   if (!jarg3) {
67478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67479     return 0;
67480   }
67481   std::string arg3_str(jarg3);
67482   arg3 = &arg3_str;
67483   {
67484     try {
67485       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67486     } catch (std::out_of_range& e) {
67487       {
67488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67489       };
67490     } catch (std::exception& e) {
67491       {
67492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (...) {
67495       {
67496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67497       };
67498     }
67499   }
67500   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67501
67502   //argout typemap for const std::string&
67503
67504
67505   //argout typemap for const std::string&
67506
67507
67508   //argout typemap for const std::string&
67509
67510   return jresult;
67511 }
67512
67513
67514 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView__SWIG_0() {
67515   void * jresult ;
67516   Dali::Toolkit::Model3dView *result = 0 ;
67517
67518   {
67519     try {
67520       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67521     } catch (std::out_of_range& e) {
67522       {
67523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67524       };
67525     } catch (std::exception& e) {
67526       {
67527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67528       };
67529     } catch (...) {
67530       {
67531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67532       };
67533     }
67534   }
67535   jresult = (void *)result;
67536   return jresult;
67537 }
67538
67539
67540 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Model3dView(void * jarg1) {
67541   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67542
67543   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67544   {
67545     try {
67546       delete arg1;
67547     } catch (std::out_of_range& e) {
67548       {
67549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67550       };
67551     } catch (std::exception& e) {
67552       {
67553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67554       };
67555     } catch (...) {
67556       {
67557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67558       };
67559     }
67560   }
67561 }
67562
67563
67564 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Model3dView__SWIG_1(void * jarg1) {
67565   void * jresult ;
67566   Dali::Toolkit::Model3dView *arg1 = 0 ;
67567   Dali::Toolkit::Model3dView *result = 0 ;
67568
67569   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67570   if (!arg1) {
67571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67572     return 0;
67573   }
67574   {
67575     try {
67576       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67577     } catch (std::out_of_range& e) {
67578       {
67579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67580       };
67581     } catch (std::exception& e) {
67582       {
67583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67584       };
67585     } catch (...) {
67586       {
67587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67588       };
67589     }
67590   }
67591   jresult = (void *)result;
67592   return jresult;
67593 }
67594
67595
67596 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_Assign(void * jarg1, void * jarg2) {
67597   void * jresult ;
67598   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67599   Dali::Toolkit::Model3dView *arg2 = 0 ;
67600   Dali::Toolkit::Model3dView *result = 0 ;
67601
67602   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67603   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67604   if (!arg2) {
67605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67606     return 0;
67607   }
67608   {
67609     try {
67610       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67611     } catch (std::out_of_range& e) {
67612       {
67613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67614       };
67615     } catch (std::exception& e) {
67616       {
67617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67618       };
67619     } catch (...) {
67620       {
67621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67622       };
67623     }
67624   }
67625   jresult = (void *)result;
67626   return jresult;
67627 }
67628
67629
67630 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Model3dView_DownCast(void * jarg1) {
67631   void * jresult ;
67632   Dali::BaseHandle arg1 ;
67633   Dali::BaseHandle *argp1 ;
67634   Dali::Toolkit::Model3dView result;
67635
67636   argp1 = (Dali::BaseHandle *)jarg1;
67637   if (!argp1) {
67638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67639     return 0;
67640   }
67641   arg1 = *argp1;
67642   {
67643     try {
67644       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67645     } catch (std::out_of_range& e) {
67646       {
67647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67648       };
67649     } catch (std::exception& e) {
67650       {
67651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67652       };
67653     } catch (...) {
67654       {
67655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67656       };
67657     }
67658   }
67659   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67660   return jresult;
67661 }
67662
67663
67664 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_SCROLL_DIRECTION_get() {
67665   int jresult ;
67666   int result;
67667
67668   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67669   jresult = (int)result;
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67675   int jresult ;
67676   int result;
67677
67678   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67679   jresult = (int)result;
67680   return jresult;
67681 }
67682
67683
67684 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67685   int jresult ;
67686   int result;
67687
67688   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67689   jresult = (int)result;
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67695   int jresult ;
67696   int result;
67697
67698   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67699   jresult = (int)result;
67700   return jresult;
67701 }
67702
67703
67704 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67705   int jresult ;
67706   int result;
67707
67708   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67709   jresult = (int)result;
67710   return jresult;
67711 }
67712
67713
67714 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67715   int jresult ;
67716   int result;
67717
67718   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67719   jresult = (int)result;
67720   return jresult;
67721 }
67722
67723
67724 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67725   int jresult ;
67726   int result;
67727
67728   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67729   jresult = (int)result;
67730   return jresult;
67731 }
67732
67733
67734 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67735   int jresult ;
67736   int result;
67737
67738   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67739   jresult = (int)result;
67740   return jresult;
67741 }
67742
67743
67744 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67745   int jresult ;
67746   int result;
67747
67748   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67749   jresult = (int)result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar_Property() {
67755   void * jresult ;
67756   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67757
67758   {
67759     try {
67760       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67761     } catch (std::out_of_range& e) {
67762       {
67763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67764       };
67765     } catch (std::exception& e) {
67766       {
67767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67768       };
67769     } catch (...) {
67770       {
67771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67772       };
67773     }
67774   }
67775   jresult = (void *)result;
67776   return jresult;
67777 }
67778
67779
67780 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollBar_Property(void * jarg1) {
67781   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67782
67783   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67784   {
67785     try {
67786       delete arg1;
67787     } catch (std::out_of_range& e) {
67788       {
67789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67790       };
67791     } catch (std::exception& e) {
67792       {
67793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67794       };
67795     } catch (...) {
67796       {
67797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67798       };
67799     }
67800   }
67801 }
67802
67803
67804 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar__SWIG_0() {
67805   void * jresult ;
67806   Dali::Toolkit::ScrollBar *result = 0 ;
67807
67808   {
67809     try {
67810       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67811     } catch (std::out_of_range& e) {
67812       {
67813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67814       };
67815     } catch (std::exception& e) {
67816       {
67817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67818       };
67819     } catch (...) {
67820       {
67821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67822       };
67823     }
67824   }
67825   jresult = (void *)result;
67826   return jresult;
67827 }
67828
67829
67830 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollBar__SWIG_1(void * jarg1) {
67831   void * jresult ;
67832   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67833   Dali::Toolkit::ScrollBar *result = 0 ;
67834
67835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67836   if (!arg1) {
67837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67838     return 0;
67839   }
67840   {
67841     try {
67842       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67843     } catch (std::out_of_range& e) {
67844       {
67845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67846       };
67847     } catch (std::exception& e) {
67848       {
67849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67850       };
67851     } catch (...) {
67852       {
67853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67854       };
67855     }
67856   }
67857   jresult = (void *)result;
67858   return jresult;
67859 }
67860
67861
67862 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_Assign(void * jarg1, void * jarg2) {
67863   void * jresult ;
67864   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67865   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67866   Dali::Toolkit::ScrollBar *result = 0 ;
67867
67868   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67869   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67870   if (!arg2) {
67871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67872     return 0;
67873   }
67874   {
67875     try {
67876       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67877     } catch (std::out_of_range& e) {
67878       {
67879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67880       };
67881     } catch (std::exception& e) {
67882       {
67883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67884       };
67885     } catch (...) {
67886       {
67887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67888       };
67889     }
67890   }
67891   jresult = (void *)result;
67892   return jresult;
67893 }
67894
67895
67896 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollBar(void * jarg1) {
67897   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67898
67899   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67900   {
67901     try {
67902       delete arg1;
67903     } catch (std::out_of_range& e) {
67904       {
67905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67906       };
67907     } catch (std::exception& e) {
67908       {
67909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67910       };
67911     } catch (...) {
67912       {
67913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67914       };
67915     }
67916   }
67917 }
67918
67919
67920 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_New__SWIG_0(int jarg1) {
67921   void * jresult ;
67922   Dali::Toolkit::ScrollBar::Direction arg1 ;
67923   Dali::Toolkit::ScrollBar result;
67924
67925   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67926   {
67927     try {
67928       result = Dali::Toolkit::ScrollBar::New(arg1);
67929     } catch (std::out_of_range& e) {
67930       {
67931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (std::exception& e) {
67934       {
67935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67936       };
67937     } catch (...) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67940       };
67941     }
67942   }
67943   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67944   return jresult;
67945 }
67946
67947
67948 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_New__SWIG_1() {
67949   void * jresult ;
67950   Dali::Toolkit::ScrollBar result;
67951
67952   {
67953     try {
67954       result = Dali::Toolkit::ScrollBar::New();
67955     } catch (std::out_of_range& e) {
67956       {
67957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67958       };
67959     } catch (std::exception& e) {
67960       {
67961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67962       };
67963     } catch (...) {
67964       {
67965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67966       };
67967     }
67968   }
67969   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67970   return jresult;
67971 }
67972
67973
67974 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_DownCast(void * jarg1) {
67975   void * jresult ;
67976   Dali::BaseHandle arg1 ;
67977   Dali::BaseHandle *argp1 ;
67978   Dali::Toolkit::ScrollBar result;
67979
67980   argp1 = (Dali::BaseHandle *)jarg1;
67981   if (!argp1) {
67982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67983     return 0;
67984   }
67985   arg1 = *argp1;
67986   {
67987     try {
67988       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (...) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68000       };
68001     }
68002   }
68003   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68004   return jresult;
68005 }
68006
68007
68008 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68009   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68010   Dali::Handle arg2 ;
68011   Dali::Property::Index arg3 ;
68012   Dali::Property::Index arg4 ;
68013   Dali::Property::Index arg5 ;
68014   Dali::Property::Index arg6 ;
68015   Dali::Handle *argp2 ;
68016
68017   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68018   argp2 = (Dali::Handle *)jarg2;
68019   if (!argp2) {
68020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68021     return ;
68022   }
68023   arg2 = *argp2;
68024   arg3 = (Dali::Property::Index)jarg3;
68025   arg4 = (Dali::Property::Index)jarg4;
68026   arg5 = (Dali::Property::Index)jarg5;
68027   arg6 = (Dali::Property::Index)jarg6;
68028   {
68029     try {
68030       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68031     } catch (std::out_of_range& e) {
68032       {
68033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68034       };
68035     } catch (std::exception& e) {
68036       {
68037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68038       };
68039     } catch (...) {
68040       {
68041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68042       };
68043     }
68044   }
68045 }
68046
68047
68048 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68049   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68050   Dali::Actor arg2 ;
68051   Dali::Actor *argp2 ;
68052
68053   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68054   argp2 = (Dali::Actor *)jarg2;
68055   if (!argp2) {
68056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68057     return ;
68058   }
68059   arg2 = *argp2;
68060   {
68061     try {
68062       (arg1)->SetScrollIndicator(arg2);
68063     } catch (std::out_of_range& e) {
68064       {
68065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68066       };
68067     } catch (std::exception& e) {
68068       {
68069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68070       };
68071     } catch (...) {
68072       {
68073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68074       };
68075     }
68076   }
68077 }
68078
68079
68080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollIndicator(void * jarg1) {
68081   void * jresult ;
68082   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68083   Dali::Actor result;
68084
68085   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68086   {
68087     try {
68088       result = (arg1)->GetScrollIndicator();
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68096       };
68097     } catch (...) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68100       };
68101     }
68102   }
68103   jresult = new Dali::Actor((const Dali::Actor &)result);
68104   return jresult;
68105 }
68106
68107
68108 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68109   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68110   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68111
68112   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68113   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68114   if (!arg2) {
68115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68116     return ;
68117   }
68118   {
68119     try {
68120       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68121     } catch (std::out_of_range& e) {
68122       {
68123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68124       };
68125     } catch (std::exception& e) {
68126       {
68127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68128       };
68129     } catch (...) {
68130       {
68131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68132       };
68133     }
68134   }
68135 }
68136
68137
68138 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68139   void * jresult ;
68140   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68141   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68142
68143   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68144   {
68145     try {
68146       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68147     } catch (std::out_of_range& e) {
68148       {
68149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68150       };
68151     } catch (std::exception& e) {
68152       {
68153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68154       };
68155     } catch (...) {
68156       {
68157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68158       };
68159     }
68160   }
68161   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68162   return jresult;
68163 }
68164
68165
68166 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68167   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68168   Dali::Toolkit::ScrollBar::Direction arg2 ;
68169
68170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68171   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68172   {
68173     try {
68174       (arg1)->SetScrollDirection(arg2);
68175     } catch (std::out_of_range& e) {
68176       {
68177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68178       };
68179     } catch (std::exception& e) {
68180       {
68181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68186       };
68187     }
68188   }
68189 }
68190
68191
68192 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_GetScrollDirection(void * jarg1) {
68193   int jresult ;
68194   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68195   Dali::Toolkit::ScrollBar::Direction result;
68196
68197   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68198   {
68199     try {
68200       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68201     } catch (std::out_of_range& e) {
68202       {
68203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68204       };
68205     } catch (std::exception& e) {
68206       {
68207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68208       };
68209     } catch (...) {
68210       {
68211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68212       };
68213     }
68214   }
68215   jresult = (int)result;
68216   return jresult;
68217 }
68218
68219
68220 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68221   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68222   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68223
68224   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68225   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68226   {
68227     try {
68228       (arg1)->SetIndicatorHeightPolicy(arg2);
68229     } catch (std::out_of_range& e) {
68230       {
68231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68232       };
68233     } catch (std::exception& e) {
68234       {
68235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68236       };
68237     } catch (...) {
68238       {
68239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68240       };
68241     }
68242   }
68243 }
68244
68245
68246 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68247   int jresult ;
68248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68249   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68250
68251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68252   {
68253     try {
68254       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68255     } catch (std::out_of_range& e) {
68256       {
68257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68258       };
68259     } catch (std::exception& e) {
68260       {
68261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68262       };
68263     } catch (...) {
68264       {
68265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68266       };
68267     }
68268   }
68269   jresult = (int)result;
68270   return jresult;
68271 }
68272
68273
68274 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68275   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68276   float arg2 ;
68277
68278   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68279   arg2 = (float)jarg2;
68280   {
68281     try {
68282       (arg1)->SetIndicatorFixedHeight(arg2);
68283     } catch (std::out_of_range& e) {
68284       {
68285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68286       };
68287     } catch (std::exception& e) {
68288       {
68289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68290       };
68291     } catch (...) {
68292       {
68293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68294       };
68295     }
68296   }
68297 }
68298
68299
68300 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68301   float jresult ;
68302   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68303   float result;
68304
68305   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68306   {
68307     try {
68308       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68309     } catch (std::out_of_range& e) {
68310       {
68311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68312       };
68313     } catch (std::exception& e) {
68314       {
68315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68316       };
68317     } catch (...) {
68318       {
68319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68320       };
68321     }
68322   }
68323   jresult = result;
68324   return jresult;
68325 }
68326
68327
68328 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68329   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68330   float arg2 ;
68331
68332   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68333   arg2 = (float)jarg2;
68334   {
68335     try {
68336       (arg1)->SetIndicatorShowDuration(arg2);
68337     } catch (std::out_of_range& e) {
68338       {
68339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68340       };
68341     } catch (std::exception& e) {
68342       {
68343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68344       };
68345     } catch (...) {
68346       {
68347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68348       };
68349     }
68350   }
68351 }
68352
68353
68354 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68355   float jresult ;
68356   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68357   float result;
68358
68359   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68360   {
68361     try {
68362       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68363     } catch (std::out_of_range& e) {
68364       {
68365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68366       };
68367     } catch (std::exception& e) {
68368       {
68369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68370       };
68371     } catch (...) {
68372       {
68373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68374       };
68375     }
68376   }
68377   jresult = result;
68378   return jresult;
68379 }
68380
68381
68382 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68383   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68384   float arg2 ;
68385
68386   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68387   arg2 = (float)jarg2;
68388   {
68389     try {
68390       (arg1)->SetIndicatorHideDuration(arg2);
68391     } catch (std::out_of_range& e) {
68392       {
68393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68394       };
68395     } catch (std::exception& e) {
68396       {
68397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68398       };
68399     } catch (...) {
68400       {
68401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68402       };
68403     }
68404   }
68405 }
68406
68407
68408 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68409   float jresult ;
68410   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68411   float result;
68412
68413   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68414   {
68415     try {
68416       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68417     } catch (std::out_of_range& e) {
68418       {
68419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68420       };
68421     } catch (std::exception& e) {
68422       {
68423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (...) {
68426       {
68427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68428       };
68429     }
68430   }
68431   jresult = result;
68432   return jresult;
68433 }
68434
68435
68436 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_ShowIndicator(void * jarg1) {
68437   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68438
68439   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68440   {
68441     try {
68442       (arg1)->ShowIndicator();
68443     } catch (std::out_of_range& e) {
68444       {
68445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68446       };
68447     } catch (std::exception& e) {
68448       {
68449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68450       };
68451     } catch (...) {
68452       {
68453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68454       };
68455     }
68456   }
68457 }
68458
68459
68460 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollBar_HideIndicator(void * jarg1) {
68461   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68462
68463   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68464   {
68465     try {
68466       (arg1)->HideIndicator();
68467     } catch (std::out_of_range& e) {
68468       {
68469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68470       };
68471     } catch (std::exception& e) {
68472       {
68473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68474       };
68475     } catch (...) {
68476       {
68477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68478       };
68479     }
68480   }
68481 }
68482
68483
68484 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_PanFinishedSignal(void * jarg1) {
68485   void * jresult ;
68486   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68487   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68488
68489   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68490   {
68491     try {
68492       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68493     } catch (std::out_of_range& e) {
68494       {
68495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68496       };
68497     } catch (std::exception& e) {
68498       {
68499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (...) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68504       };
68505     }
68506   }
68507   jresult = (void *)result;
68508   return jresult;
68509 }
68510
68511
68512 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68513   void * jresult ;
68514   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68515   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68516
68517   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68518   {
68519     try {
68520       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68521     } catch (std::out_of_range& e) {
68522       {
68523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68524       };
68525     } catch (std::exception& e) {
68526       {
68527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68528       };
68529     } catch (...) {
68530       {
68531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68532       };
68533     }
68534   }
68535   jresult = (void *)result;
68536   return jresult;
68537 }
68538
68539
68540 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68541   int jresult ;
68542   int result;
68543
68544   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68545   jresult = (int)result;
68546   return jresult;
68547 }
68548
68549
68550 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68551   int jresult ;
68552   int result;
68553
68554   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68555   jresult = (int)result;
68556   return jresult;
68557 }
68558
68559
68560 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68561   int jresult ;
68562   int result;
68563
68564   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68565   jresult = (int)result;
68566   return jresult;
68567 }
68568
68569
68570 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_OVERSHOOT_SIZE_get() {
68571   int jresult ;
68572   int result;
68573
68574   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68575   jresult = (int)result;
68576   return jresult;
68577 }
68578
68579
68580 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68581   int jresult ;
68582   int result;
68583
68584   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68585   jresult = (int)result;
68586   return jresult;
68587 }
68588
68589
68590 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68591   int jresult ;
68592   int result;
68593
68594   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68595   jresult = (int)result;
68596   return jresult;
68597 }
68598
68599
68600 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68601   int jresult ;
68602   int result;
68603
68604   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68605   jresult = (int)result;
68606   return jresult;
68607 }
68608
68609
68610 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68611   int jresult ;
68612   int result;
68613
68614   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68615   jresult = (int)result;
68616   return jresult;
68617 }
68618
68619
68620 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68621   int jresult ;
68622   int result;
68623
68624   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68625   jresult = (int)result;
68626   return jresult;
68627 }
68628
68629
68630 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68631   int jresult ;
68632   int result;
68633
68634   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68635   jresult = (int)result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68641   int jresult ;
68642   int result;
68643
68644   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68645   jresult = (int)result;
68646   return jresult;
68647 }
68648
68649
68650 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68651   int jresult ;
68652   int result;
68653
68654   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68655   jresult = (int)result;
68656   return jresult;
68657 }
68658
68659
68660 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68661   int jresult ;
68662   int result;
68663
68664   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68665   jresult = (int)result;
68666   return jresult;
68667 }
68668
68669
68670 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68671   int jresult ;
68672   int result;
68673
68674   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68675   jresult = (int)result;
68676   return jresult;
68677 }
68678
68679
68680 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable_Property() {
68681   void * jresult ;
68682   Dali::Toolkit::Scrollable::Property *result = 0 ;
68683
68684   {
68685     try {
68686       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68687     } catch (std::out_of_range& e) {
68688       {
68689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68690       };
68691     } catch (std::exception& e) {
68692       {
68693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68694       };
68695     } catch (...) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68698       };
68699     }
68700   }
68701   jresult = (void *)result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Scrollable_Property(void * jarg1) {
68707   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68708
68709   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68710   {
68711     try {
68712       delete arg1;
68713     } catch (std::out_of_range& e) {
68714       {
68715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68716       };
68717     } catch (std::exception& e) {
68718       {
68719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68720       };
68721     } catch (...) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68724       };
68725     }
68726   }
68727 }
68728
68729
68730 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable__SWIG_0() {
68731   void * jresult ;
68732   Dali::Toolkit::Scrollable *result = 0 ;
68733
68734   {
68735     try {
68736       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68737     } catch (std::out_of_range& e) {
68738       {
68739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68740       };
68741     } catch (std::exception& e) {
68742       {
68743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68748       };
68749     }
68750   }
68751   jresult = (void *)result;
68752   return jresult;
68753 }
68754
68755
68756 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Scrollable__SWIG_1(void * jarg1) {
68757   void * jresult ;
68758   Dali::Toolkit::Scrollable *arg1 = 0 ;
68759   Dali::Toolkit::Scrollable *result = 0 ;
68760
68761   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68762   if (!arg1) {
68763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68764     return 0;
68765   }
68766   {
68767     try {
68768       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68776       };
68777     } catch (...) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68780       };
68781     }
68782   }
68783   jresult = (void *)result;
68784   return jresult;
68785 }
68786
68787
68788 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_Assign(void * jarg1, void * jarg2) {
68789   void * jresult ;
68790   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68791   Dali::Toolkit::Scrollable *arg2 = 0 ;
68792   Dali::Toolkit::Scrollable *result = 0 ;
68793
68794   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68795   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68796   if (!arg2) {
68797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68798     return 0;
68799   }
68800   {
68801     try {
68802       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68803     } catch (std::out_of_range& e) {
68804       {
68805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (std::exception& e) {
68808       {
68809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68810       };
68811     } catch (...) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68814       };
68815     }
68816   }
68817   jresult = (void *)result;
68818   return jresult;
68819 }
68820
68821
68822 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Scrollable(void * jarg1) {
68823   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68824
68825   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68826   {
68827     try {
68828       delete arg1;
68829     } catch (std::out_of_range& e) {
68830       {
68831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68832       };
68833     } catch (std::exception& e) {
68834       {
68835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68836       };
68837     } catch (...) {
68838       {
68839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68840       };
68841     }
68842   }
68843 }
68844
68845
68846 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_DownCast(void * jarg1) {
68847   void * jresult ;
68848   Dali::BaseHandle arg1 ;
68849   Dali::BaseHandle *argp1 ;
68850   Dali::Toolkit::Scrollable result;
68851
68852   argp1 = (Dali::BaseHandle *)jarg1;
68853   if (!argp1) {
68854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68855     return 0;
68856   }
68857   arg1 = *argp1;
68858   {
68859     try {
68860       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68861     } catch (std::out_of_range& e) {
68862       {
68863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68864       };
68865     } catch (std::exception& e) {
68866       {
68867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68868       };
68869     } catch (...) {
68870       {
68871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68872       };
68873     }
68874   }
68875   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68876   return jresult;
68877 }
68878
68879
68880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Scrollable_IsOvershootEnabled(void * jarg1) {
68881   unsigned int jresult ;
68882   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68883   bool result;
68884
68885   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68886   {
68887     try {
68888       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68889     } catch (std::out_of_range& e) {
68890       {
68891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68892       };
68893     } catch (std::exception& e) {
68894       {
68895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68896       };
68897     } catch (...) {
68898       {
68899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68900       };
68901     }
68902   }
68903   jresult = result;
68904   return jresult;
68905 }
68906
68907
68908 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68909   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68910   bool arg2 ;
68911
68912   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68913   arg2 = jarg2 ? true : false;
68914   {
68915     try {
68916       (arg1)->SetOvershootEnabled(arg2);
68917     } catch (std::out_of_range& e) {
68918       {
68919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68920       };
68921     } catch (std::exception& e) {
68922       {
68923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68928       };
68929     }
68930   }
68931 }
68932
68933
68934 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68935   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68936   Dali::Vector4 *arg2 = 0 ;
68937
68938   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68939   arg2 = (Dali::Vector4 *)jarg2;
68940   if (!arg2) {
68941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68942     return ;
68943   }
68944   {
68945     try {
68946       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68947     } catch (std::out_of_range& e) {
68948       {
68949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68950       };
68951     } catch (std::exception& e) {
68952       {
68953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68954       };
68955     } catch (...) {
68956       {
68957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68958       };
68959     }
68960   }
68961 }
68962
68963
68964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_GetOvershootEffectColor(void * jarg1) {
68965   void * jresult ;
68966   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68967   Dali::Vector4 result;
68968
68969   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68970   {
68971     try {
68972       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68973     } catch (std::out_of_range& e) {
68974       {
68975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68976       };
68977     } catch (std::exception& e) {
68978       {
68979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68980       };
68981     } catch (...) {
68982       {
68983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68984       };
68985     }
68986   }
68987   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68988   return jresult;
68989 }
68990
68991
68992 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68993   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68994   float arg2 ;
68995
68996   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68997   arg2 = (float)jarg2;
68998   {
68999     try {
69000       (arg1)->SetOvershootAnimationSpeed(arg2);
69001     } catch (std::out_of_range& e) {
69002       {
69003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69004       };
69005     } catch (std::exception& e) {
69006       {
69007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69008       };
69009     } catch (...) {
69010       {
69011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69012       };
69013     }
69014   }
69015 }
69016
69017
69018 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69019   float jresult ;
69020   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69021   float result;
69022
69023   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69024   {
69025     try {
69026       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69027     } catch (std::out_of_range& e) {
69028       {
69029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69030       };
69031     } catch (std::exception& e) {
69032       {
69033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (...) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69038       };
69039     }
69040   }
69041   jresult = result;
69042   return jresult;
69043 }
69044
69045
69046 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollStartedSignal(void * jarg1) {
69047   void * jresult ;
69048   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69049   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69050
69051   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69052   {
69053     try {
69054       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69055     } catch (std::out_of_range& e) {
69056       {
69057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69058       };
69059     } catch (std::exception& e) {
69060       {
69061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69062       };
69063     } catch (...) {
69064       {
69065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69066       };
69067     }
69068   }
69069   jresult = (void *)result;
69070   return jresult;
69071 }
69072
69073
69074 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69075   void * jresult ;
69076   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69077   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69078
69079   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69080   {
69081     try {
69082       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69083     } catch (std::out_of_range& e) {
69084       {
69085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69086       };
69087     } catch (std::exception& e) {
69088       {
69089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69090       };
69091     } catch (...) {
69092       {
69093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69094       };
69095     }
69096   }
69097   jresult = (void *)result;
69098   return jresult;
69099 }
69100
69101
69102 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Scrollable_ScrollCompletedSignal(void * jarg1) {
69103   void * jresult ;
69104   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69105   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69106
69107   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69108   {
69109     try {
69110       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69111     } catch (std::out_of_range& e) {
69112       {
69113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69114       };
69115     } catch (std::exception& e) {
69116       {
69117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69118       };
69119     } catch (...) {
69120       {
69121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69122       };
69123     }
69124   }
69125   jresult = (void *)result;
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_IsVertical(int jarg1) {
69131   unsigned int jresult ;
69132   Dali::Toolkit::ControlOrientation::Type arg1 ;
69133   bool result;
69134
69135   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69136   {
69137     try {
69138       result = (bool)Dali::Toolkit::IsVertical(arg1);
69139     } catch (std::out_of_range& e) {
69140       {
69141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69142       };
69143     } catch (std::exception& e) {
69144       {
69145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69146       };
69147     } catch (...) {
69148       {
69149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69150       };
69151     }
69152   }
69153   jresult = result;
69154   return jresult;
69155 }
69156
69157
69158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_IsHorizontal(int jarg1) {
69159   unsigned int jresult ;
69160   Dali::Toolkit::ControlOrientation::Type arg1 ;
69161   bool result;
69162
69163   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69164   {
69165     try {
69166       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69167     } catch (std::out_of_range& e) {
69168       {
69169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69170       };
69171     } catch (std::exception& e) {
69172       {
69173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69174       };
69175     } catch (...) {
69176       {
69177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69178       };
69179     }
69180   }
69181   jresult = result;
69182   return jresult;
69183 }
69184
69185
69186 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69187   void * jresult ;
69188   unsigned int arg1 ;
69189   unsigned int arg2 ;
69190   Dali::Toolkit::ItemRange *result = 0 ;
69191
69192   arg1 = (unsigned int)jarg1;
69193   arg2 = (unsigned int)jarg2;
69194   {
69195     try {
69196       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69197     } catch (std::out_of_range& e) {
69198       {
69199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69200       };
69201     } catch (std::exception& e) {
69202       {
69203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69204       };
69205     } catch (...) {
69206       {
69207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69208       };
69209     }
69210   }
69211   jresult = (void *)result;
69212   return jresult;
69213 }
69214
69215
69216 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemRange__SWIG_1(void * jarg1) {
69217   void * jresult ;
69218   Dali::Toolkit::ItemRange *arg1 = 0 ;
69219   Dali::Toolkit::ItemRange *result = 0 ;
69220
69221   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69222   if (!arg1) {
69223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69224     return 0;
69225   }
69226   {
69227     try {
69228       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69229     } catch (std::out_of_range& e) {
69230       {
69231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69232       };
69233     } catch (std::exception& e) {
69234       {
69235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69236       };
69237     } catch (...) {
69238       {
69239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69240       };
69241     }
69242   }
69243   jresult = (void *)result;
69244   return jresult;
69245 }
69246
69247
69248 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemRange_Assign(void * jarg1, void * jarg2) {
69249   void * jresult ;
69250   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69251   Dali::Toolkit::ItemRange *arg2 = 0 ;
69252   Dali::Toolkit::ItemRange *result = 0 ;
69253
69254   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69255   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69256   if (!arg2) {
69257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69258     return 0;
69259   }
69260   {
69261     try {
69262       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69263     } catch (std::out_of_range& e) {
69264       {
69265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69266       };
69267     } catch (std::exception& e) {
69268       {
69269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (...) {
69272       {
69273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69274       };
69275     }
69276   }
69277   jresult = (void *)result;
69278   return jresult;
69279 }
69280
69281
69282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69283   unsigned int jresult ;
69284   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69285   unsigned int arg2 ;
69286   bool result;
69287
69288   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69289   arg2 = (unsigned int)jarg2;
69290   {
69291     try {
69292       result = (bool)(arg1)->Within(arg2);
69293     } catch (std::out_of_range& e) {
69294       {
69295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69296       };
69297     } catch (std::exception& e) {
69298       {
69299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69300       };
69301     } catch (...) {
69302       {
69303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69304       };
69305     }
69306   }
69307   jresult = result;
69308   return jresult;
69309 }
69310
69311
69312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemRange_Intersection(void * jarg1, void * jarg2) {
69313   void * jresult ;
69314   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69315   Dali::Toolkit::ItemRange *arg2 = 0 ;
69316   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69317
69318   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69319   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69320   if (!arg2) {
69321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69322     return 0;
69323   }
69324   {
69325     try {
69326       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69327     } catch (std::out_of_range& e) {
69328       {
69329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69330       };
69331     } catch (std::exception& e) {
69332       {
69333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (...) {
69336       {
69337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69338       };
69339     }
69340   }
69341   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69342   return jresult;
69343 }
69344
69345
69346 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69347   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69348   unsigned int arg2 ;
69349
69350   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69351   arg2 = (unsigned int)jarg2;
69352   if (arg1) (arg1)->begin = arg2;
69353 }
69354
69355
69356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_begin_get(void * jarg1) {
69357   unsigned int jresult ;
69358   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69359   unsigned int result;
69360
69361   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69362   result = (unsigned int) ((arg1)->begin);
69363   jresult = result;
69364   return jresult;
69365 }
69366
69367
69368 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69369   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69370   unsigned int arg2 ;
69371
69372   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69373   arg2 = (unsigned int)jarg2;
69374   if (arg1) (arg1)->end = arg2;
69375 }
69376
69377
69378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemRange_end_get(void * jarg1) {
69379   unsigned int jresult ;
69380   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69381   unsigned int result;
69382
69383   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69384   result = (unsigned int) ((arg1)->end);
69385   jresult = result;
69386   return jresult;
69387 }
69388
69389
69390 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemRange(void * jarg1) {
69391   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69392
69393   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69394   {
69395     try {
69396       delete arg1;
69397     } catch (std::out_of_range& e) {
69398       {
69399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69400       };
69401     } catch (std::exception& e) {
69402       {
69403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69404       };
69405     } catch (...) {
69406       {
69407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69408       };
69409     }
69410   }
69411 }
69412
69413
69414 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemLayout(void * jarg1) {
69415   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69416
69417   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69418   {
69419     try {
69420       delete arg1;
69421     } catch (std::out_of_range& e) {
69422       {
69423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69424       };
69425     } catch (std::exception& e) {
69426       {
69427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69428       };
69429     } catch (...) {
69430       {
69431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69432       };
69433     }
69434   }
69435 }
69436
69437
69438 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69439   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69440   Dali::Toolkit::ControlOrientation::Type arg2 ;
69441
69442   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69443   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69444   {
69445     try {
69446       (arg1)->SetOrientation(arg2);
69447     } catch (std::out_of_range& e) {
69448       {
69449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69450       };
69451     } catch (std::exception& e) {
69452       {
69453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69454       };
69455     } catch (...) {
69456       {
69457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69458       };
69459     }
69460   }
69461 }
69462
69463
69464 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemLayout_GetOrientation(void * jarg1) {
69465   int jresult ;
69466   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69467   Dali::Toolkit::ControlOrientation::Type result;
69468
69469   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69470   {
69471     try {
69472       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69473     } catch (std::out_of_range& e) {
69474       {
69475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (std::exception& e) {
69478       {
69479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69484       };
69485     }
69486   }
69487   jresult = (int)result;
69488   return jresult;
69489 }
69490
69491
69492 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69493   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69494   Dali::Property::Map *arg2 = 0 ;
69495
69496   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69497   arg2 = (Dali::Property::Map *)jarg2;
69498   if (!arg2) {
69499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69500     return ;
69501   }
69502   {
69503     try {
69504       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69505     } catch (std::out_of_range& e) {
69506       {
69507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69508       };
69509     } catch (std::exception& e) {
69510       {
69511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69512       };
69513     } catch (...) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69516       };
69517     }
69518   }
69519 }
69520
69521
69522 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetLayoutProperties(void * jarg1) {
69523   void * jresult ;
69524   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69525   Dali::Property::Map result;
69526
69527   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69528   {
69529     try {
69530       result = (arg1)->GetLayoutProperties();
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69538       };
69539     } catch (...) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69542       };
69543     }
69544   }
69545   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69546   return jresult;
69547 }
69548
69549
69550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemLayout_HasLayoutChanged(void * jarg1) {
69551   unsigned int jresult ;
69552   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69553   bool result;
69554
69555   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69556   {
69557     try {
69558       result = (bool)(arg1)->HasLayoutChanged();
69559     } catch (std::out_of_range& e) {
69560       {
69561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69562       };
69563     } catch (std::exception& e) {
69564       {
69565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69566       };
69567     } catch (...) {
69568       {
69569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69570       };
69571     }
69572   }
69573   jresult = result;
69574   return jresult;
69575 }
69576
69577
69578 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_ResetLayoutChangedFlag(void * jarg1) {
69579   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69580
69581   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69582   {
69583     try {
69584       (arg1)->ResetLayoutChangedFlag();
69585     } catch (std::out_of_range& e) {
69586       {
69587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69588       };
69589     } catch (std::exception& e) {
69590       {
69591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69592       };
69593     } catch (...) {
69594       {
69595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69596       };
69597     }
69598   }
69599 }
69600
69601
69602 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69603   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69604   unsigned int arg2 ;
69605   Dali::Vector3 *arg3 = 0 ;
69606   Dali::Vector3 *arg4 = 0 ;
69607
69608   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69609   arg2 = (unsigned int)jarg2;
69610   arg3 = (Dali::Vector3 *)jarg3;
69611   if (!arg3) {
69612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69613     return ;
69614   }
69615   arg4 = (Dali::Vector3 *)jarg4;
69616   if (!arg4) {
69617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69618     return ;
69619   }
69620   {
69621     try {
69622       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (...) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69634       };
69635     }
69636   }
69637 }
69638
69639
69640 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69641   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69642   Dali::Vector3 *arg2 = 0 ;
69643
69644   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69645   arg2 = (Dali::Vector3 *)jarg2;
69646   if (!arg2) {
69647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69648     return ;
69649   }
69650   {
69651     try {
69652       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69653     } catch (std::out_of_range& e) {
69654       {
69655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69656       };
69657     } catch (std::exception& e) {
69658       {
69659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69660       };
69661     } catch (...) {
69662       {
69663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69664       };
69665     }
69666   }
69667 }
69668
69669
69670 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69671   float jresult ;
69672   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69673   unsigned int arg2 ;
69674   Dali::Vector3 arg3 ;
69675   Dali::Vector3 *argp3 ;
69676   float result;
69677
69678   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69679   arg2 = (unsigned int)jarg2;
69680   argp3 = (Dali::Vector3 *)jarg3;
69681   if (!argp3) {
69682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69683     return 0;
69684   }
69685   arg3 = *argp3;
69686   {
69687     try {
69688       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69689     } catch (std::out_of_range& e) {
69690       {
69691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69692       };
69693     } catch (std::exception& e) {
69694       {
69695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (...) {
69698       {
69699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69700       };
69701     }
69702   }
69703   jresult = result;
69704   return jresult;
69705 }
69706
69707
69708 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69709   float jresult ;
69710   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69711   float arg2 ;
69712   float result;
69713
69714   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69715   arg2 = (float)jarg2;
69716   {
69717     try {
69718       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69719     } catch (std::out_of_range& e) {
69720       {
69721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69722       };
69723     } catch (std::exception& e) {
69724       {
69725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69726       };
69727     } catch (...) {
69728       {
69729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69730       };
69731     }
69732   }
69733   jresult = result;
69734   return jresult;
69735 }
69736
69737
69738 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69739   float jresult ;
69740   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69741   unsigned int arg2 ;
69742   float result;
69743
69744   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69745   arg2 = (unsigned int)jarg2;
69746   {
69747     try {
69748       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (...) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69760       };
69761     }
69762   }
69763   jresult = result;
69764   return jresult;
69765 }
69766
69767
69768 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69769   void * jresult ;
69770   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69771   float arg2 ;
69772   Dali::Vector3 arg3 ;
69773   Dali::Vector3 *argp3 ;
69774   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69775
69776   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69777   arg2 = (float)jarg2;
69778   argp3 = (Dali::Vector3 *)jarg3;
69779   if (!argp3) {
69780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69781     return 0;
69782   }
69783   arg3 = *argp3;
69784   {
69785     try {
69786       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69787     } catch (std::out_of_range& e) {
69788       {
69789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69790       };
69791     } catch (std::exception& e) {
69792       {
69793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69794       };
69795     } catch (...) {
69796       {
69797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69798       };
69799     }
69800   }
69801   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69802   return jresult;
69803 }
69804
69805
69806 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69807   float jresult ;
69808   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69809   int arg2 ;
69810   float arg3 ;
69811   Dali::Vector3 *arg4 = 0 ;
69812   float result;
69813
69814   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69815   arg2 = (int)jarg2;
69816   arg3 = (float)jarg3;
69817   arg4 = (Dali::Vector3 *)jarg4;
69818   if (!arg4) {
69819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69820     return 0;
69821   }
69822   {
69823     try {
69824       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69825     } catch (std::out_of_range& e) {
69826       {
69827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69828       };
69829     } catch (std::exception& e) {
69830       {
69831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69832       };
69833     } catch (...) {
69834       {
69835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69836       };
69837     }
69838   }
69839   jresult = result;
69840   return jresult;
69841 }
69842
69843
69844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69845   unsigned int jresult ;
69846   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69847   Dali::Vector3 arg2 ;
69848   Dali::Vector3 *argp2 ;
69849   unsigned int result;
69850
69851   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69852   argp2 = (Dali::Vector3 *)jarg2;
69853   if (!argp2) {
69854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69855     return 0;
69856   }
69857   arg2 = *argp2;
69858   {
69859     try {
69860       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69861     } catch (std::out_of_range& e) {
69862       {
69863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69864       };
69865     } catch (std::exception& e) {
69866       {
69867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69868       };
69869     } catch (...) {
69870       {
69871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69872       };
69873     }
69874   }
69875   jresult = result;
69876   return jresult;
69877 }
69878
69879
69880 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69881   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69882   unsigned int arg2 ;
69883   Dali::Vector3 *arg3 = 0 ;
69884   Dali::Vector3 *arg4 = 0 ;
69885
69886   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69887   arg2 = (unsigned int)jarg2;
69888   arg3 = (Dali::Vector3 *)jarg3;
69889   if (!arg3) {
69890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69891     return ;
69892   }
69893   arg4 = (Dali::Vector3 *)jarg4;
69894   if (!arg4) {
69895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69896     return ;
69897   }
69898   {
69899     try {
69900       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69908       };
69909     } catch (...) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69912       };
69913     }
69914   }
69915 }
69916
69917
69918 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetScrollDirection(void * jarg1) {
69919   void * jresult ;
69920   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69921   Dali::Degree result;
69922
69923   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69924   {
69925     try {
69926       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69927     } catch (std::out_of_range& e) {
69928       {
69929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69930       };
69931     } catch (std::exception& e) {
69932       {
69933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (...) {
69936       {
69937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69938       };
69939     }
69940   }
69941   jresult = new Dali::Degree((const Dali::Degree &)result);
69942   return jresult;
69943 }
69944
69945
69946 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69947   float jresult ;
69948   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69949   float result;
69950
69951   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69952   {
69953     try {
69954       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69955     } catch (std::out_of_range& e) {
69956       {
69957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69958       };
69959     } catch (std::exception& e) {
69960       {
69961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69962       };
69963     } catch (...) {
69964       {
69965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69966       };
69967     }
69968   }
69969   jresult = result;
69970   return jresult;
69971 }
69972
69973
69974 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69975   float jresult ;
69976   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69977   float result;
69978
69979   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69980   {
69981     try {
69982       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69983     } catch (std::out_of_range& e) {
69984       {
69985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69986       };
69987     } catch (std::exception& e) {
69988       {
69989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69990       };
69991     } catch (...) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69994       };
69995     }
69996   }
69997   jresult = result;
69998   return jresult;
69999 }
70000
70001
70002 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70003   float jresult ;
70004   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70005   float result;
70006
70007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70008   {
70009     try {
70010       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70011     } catch (std::out_of_range& e) {
70012       {
70013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (std::exception& e) {
70016       {
70017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (...) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70022       };
70023     }
70024   }
70025   jresult = result;
70026   return jresult;
70027 }
70028
70029
70030 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70031   int jresult ;
70032   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70033   int arg2 ;
70034   int arg3 ;
70035   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70036   bool arg5 ;
70037   int result;
70038
70039   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70040   arg2 = (int)jarg2;
70041   arg3 = (int)jarg3;
70042   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70043   arg5 = jarg5 ? true : false;
70044   {
70045     try {
70046       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (...) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70058       };
70059     }
70060   }
70061   jresult = result;
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70067   float jresult ;
70068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70069   float result;
70070
70071   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70072   {
70073     try {
70074       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70075     } catch (std::out_of_range& e) {
70076       {
70077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (std::exception& e) {
70080       {
70081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (...) {
70084       {
70085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70086       };
70087     }
70088   }
70089   jresult = result;
70090   return jresult;
70091 }
70092
70093
70094 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70095   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70096   Dali::Actor *arg2 = 0 ;
70097   int arg3 ;
70098   Dali::Vector3 *arg4 = 0 ;
70099   Dali::Actor *arg5 = 0 ;
70100
70101   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70102   arg2 = (Dali::Actor *)jarg2;
70103   if (!arg2) {
70104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70105     return ;
70106   }
70107   arg3 = (int)jarg3;
70108   arg4 = (Dali::Vector3 *)jarg4;
70109   if (!arg4) {
70110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70111     return ;
70112   }
70113   arg5 = (Dali::Actor *)jarg5;
70114   if (!arg5) {
70115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70116     return ;
70117   }
70118   {
70119     try {
70120       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70121     } catch (std::out_of_range& e) {
70122       {
70123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70124       };
70125     } catch (std::exception& e) {
70126       {
70127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70128       };
70129     } catch (...) {
70130       {
70131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70132       };
70133     }
70134   }
70135 }
70136
70137
70138 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70139   void * jresult ;
70140   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70141   int arg2 ;
70142   float arg3 ;
70143   Dali::Vector3 *arg4 = 0 ;
70144   Dali::Vector3 result;
70145
70146   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70147   arg2 = (int)jarg2;
70148   arg3 = (float)jarg3;
70149   arg4 = (Dali::Vector3 *)jarg4;
70150   if (!arg4) {
70151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70152     return 0;
70153   }
70154   {
70155     try {
70156       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70157     } catch (std::out_of_range& e) {
70158       {
70159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (std::exception& e) {
70162       {
70163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (...) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70168       };
70169     }
70170   }
70171   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70172   return jresult;
70173 }
70174
70175
70176 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_NewItemLayout(int jarg1) {
70177   void * jresult ;
70178   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70179   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70180
70181   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70182   {
70183     try {
70184       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70185     } catch (std::out_of_range& e) {
70186       {
70187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70188       };
70189     } catch (std::exception& e) {
70190       {
70191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70192       };
70193     } catch (...) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70196       };
70197     }
70198   }
70199   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70200   return jresult;
70201 }
70202
70203
70204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemFactory(void * jarg1) {
70205   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70206
70207   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70208   {
70209     try {
70210       delete arg1;
70211     } catch (std::out_of_range& e) {
70212       {
70213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70214       };
70215     } catch (std::exception& e) {
70216       {
70217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70222       };
70223     }
70224   }
70225 }
70226
70227
70228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemFactory_GetNumberOfItems(void * jarg1) {
70229   unsigned int jresult ;
70230   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70231   unsigned int result;
70232
70233   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70234   {
70235     try {
70236       result = (unsigned int)(arg1)->GetNumberOfItems();
70237     } catch (std::out_of_range& e) {
70238       {
70239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70240       };
70241     } catch (std::exception& e) {
70242       {
70243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70244       };
70245     } catch (...) {
70246       {
70247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70248       };
70249     }
70250   }
70251   jresult = result;
70252   return jresult;
70253 }
70254
70255
70256 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70257   void * jresult ;
70258   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70259   unsigned int arg2 ;
70260   Dali::Actor result;
70261
70262   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70263   arg2 = (unsigned int)jarg2;
70264   {
70265     try {
70266       result = (arg1)->NewItem(arg2);
70267     } catch (std::out_of_range& e) {
70268       {
70269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70270       };
70271     } catch (std::exception& e) {
70272       {
70273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70274       };
70275     } catch (...) {
70276       {
70277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70278       };
70279     }
70280   }
70281   jresult = new Dali::Actor((const Dali::Actor &)result);
70282   return jresult;
70283 }
70284
70285
70286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70287   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70288   unsigned int arg2 ;
70289   Dali::Actor arg3 ;
70290   Dali::Actor *argp3 ;
70291
70292   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70293   arg2 = (unsigned int)jarg2;
70294   argp3 = (Dali::Actor *)jarg3;
70295   if (!argp3) {
70296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70297     return ;
70298   }
70299   arg3 = *argp3;
70300   {
70301     try {
70302       (arg1)->ItemReleased(arg2,arg3);
70303     } catch (std::out_of_range& e) {
70304       {
70305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70306       };
70307     } catch (std::exception& e) {
70308       {
70309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70310       };
70311     } catch (...) {
70312       {
70313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70314       };
70315     }
70316   }
70317 }
70318
70319
70320 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70321   int jresult ;
70322   int result;
70323
70324   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70325   jresult = (int)result;
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70331   int jresult ;
70332   int result;
70333
70334   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70335   jresult = (int)result;
70336   return jresult;
70337 }
70338
70339
70340 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70341   int jresult ;
70342   int result;
70343
70344   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70345   jresult = (int)result;
70346   return jresult;
70347 }
70348
70349
70350 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70351   int jresult ;
70352   int result;
70353
70354   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70355   jresult = (int)result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_REFRESH_INTERVAL_get() {
70361   int jresult ;
70362   int result;
70363
70364   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70365   jresult = (int)result;
70366   return jresult;
70367 }
70368
70369
70370 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_LAYOUT_POSITION_get() {
70371   int jresult ;
70372   int result;
70373
70374   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70375   jresult = (int)result;
70376   return jresult;
70377 }
70378
70379
70380 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_SPEED_get() {
70381   int jresult ;
70382   int result;
70383
70384   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70385   jresult = (int)result;
70386   return jresult;
70387 }
70388
70389
70390 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_OVERSHOOT_get() {
70391   int jresult ;
70392   int result;
70393
70394   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70395   jresult = (int)result;
70396   return jresult;
70397 }
70398
70399
70400 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_DIRECTION_get() {
70401   int jresult ;
70402   int result;
70403
70404   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70405   jresult = (int)result;
70406   return jresult;
70407 }
70408
70409
70410 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_LAYOUT_ORIENTATION_get() {
70411   int jresult ;
70412   int result;
70413
70414   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70415   jresult = (int)result;
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70421   int jresult ;
70422   int result;
70423
70424   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70425   jresult = (int)result;
70426   return jresult;
70427 }
70428
70429
70430 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView_Property() {
70431   void * jresult ;
70432   Dali::Toolkit::ItemView::Property *result = 0 ;
70433
70434   {
70435     try {
70436       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70437     } catch (std::out_of_range& e) {
70438       {
70439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70440       };
70441     } catch (std::exception& e) {
70442       {
70443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70444       };
70445     } catch (...) {
70446       {
70447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70448       };
70449     }
70450   }
70451   jresult = (void *)result;
70452   return jresult;
70453 }
70454
70455
70456 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemView_Property(void * jarg1) {
70457   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70458
70459   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70460   {
70461     try {
70462       delete arg1;
70463     } catch (std::out_of_range& e) {
70464       {
70465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70466       };
70467     } catch (std::exception& e) {
70468       {
70469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70470       };
70471     } catch (...) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70474       };
70475     }
70476   }
70477 }
70478
70479
70480 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView__SWIG_0() {
70481   void * jresult ;
70482   Dali::Toolkit::ItemView *result = 0 ;
70483
70484   {
70485     try {
70486       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70487     } catch (std::out_of_range& e) {
70488       {
70489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (std::exception& e) {
70492       {
70493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70494       };
70495     } catch (...) {
70496       {
70497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70498       };
70499     }
70500   }
70501   jresult = (void *)result;
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemView__SWIG_1(void * jarg1) {
70507   void * jresult ;
70508   Dali::Toolkit::ItemView *arg1 = 0 ;
70509   Dali::Toolkit::ItemView *result = 0 ;
70510
70511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70512   if (!arg1) {
70513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70514     return 0;
70515   }
70516   {
70517     try {
70518       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70519     } catch (std::out_of_range& e) {
70520       {
70521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70522       };
70523     } catch (std::exception& e) {
70524       {
70525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70530       };
70531     }
70532   }
70533   jresult = (void *)result;
70534   return jresult;
70535 }
70536
70537
70538 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_Assign(void * jarg1, void * jarg2) {
70539   void * jresult ;
70540   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70541   Dali::Toolkit::ItemView *arg2 = 0 ;
70542   Dali::Toolkit::ItemView *result = 0 ;
70543
70544   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70545   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70546   if (!arg2) {
70547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70548     return 0;
70549   }
70550   {
70551     try {
70552       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70553     } catch (std::out_of_range& e) {
70554       {
70555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70556       };
70557     } catch (std::exception& e) {
70558       {
70559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70560       };
70561     } catch (...) {
70562       {
70563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70564       };
70565     }
70566   }
70567   jresult = (void *)result;
70568   return jresult;
70569 }
70570
70571
70572 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemView(void * jarg1) {
70573   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70574
70575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70576   {
70577     try {
70578       delete arg1;
70579     } catch (std::out_of_range& e) {
70580       {
70581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70582       };
70583     } catch (std::exception& e) {
70584       {
70585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70586       };
70587     } catch (...) {
70588       {
70589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70590       };
70591     }
70592   }
70593 }
70594
70595
70596 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_New(void * jarg1) {
70597   void * jresult ;
70598   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70599   Dali::Toolkit::ItemView result;
70600
70601   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70602   if (!arg1) {
70603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70604     return 0;
70605   }
70606   {
70607     try {
70608       result = Dali::Toolkit::ItemView::New(*arg1);
70609     } catch (std::out_of_range& e) {
70610       {
70611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70612       };
70613     } catch (std::exception& e) {
70614       {
70615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70616       };
70617     } catch (...) {
70618       {
70619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70620       };
70621     }
70622   }
70623   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70624   return jresult;
70625 }
70626
70627
70628 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_DownCast(void * jarg1) {
70629   void * jresult ;
70630   Dali::BaseHandle arg1 ;
70631   Dali::BaseHandle *argp1 ;
70632   Dali::Toolkit::ItemView result;
70633
70634   argp1 = (Dali::BaseHandle *)jarg1;
70635   if (!argp1) {
70636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70637     return 0;
70638   }
70639   arg1 = *argp1;
70640   {
70641     try {
70642       result = Dali::Toolkit::ItemView::DownCast(arg1);
70643     } catch (std::out_of_range& e) {
70644       {
70645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70646       };
70647     } catch (std::exception& e) {
70648       {
70649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70650       };
70651     } catch (...) {
70652       {
70653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70654       };
70655     }
70656   }
70657   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70658   return jresult;
70659 }
70660
70661
70662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetLayoutCount(void * jarg1) {
70663   unsigned int jresult ;
70664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70665   unsigned int result;
70666
70667   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70668   {
70669     try {
70670       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70671     } catch (std::out_of_range& e) {
70672       {
70673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70674       };
70675     } catch (std::exception& e) {
70676       {
70677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70678       };
70679     } catch (...) {
70680       {
70681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70682       };
70683     }
70684   }
70685   jresult = result;
70686   return jresult;
70687 }
70688
70689
70690 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_AddLayout(void * jarg1, void * jarg2) {
70691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70692   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70693
70694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70695   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70696   if (!arg2) {
70697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70698     return ;
70699   }
70700   {
70701     try {
70702       (arg1)->AddLayout(*arg2);
70703     } catch (std::out_of_range& e) {
70704       {
70705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70706       };
70707     } catch (std::exception& e) {
70708       {
70709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70714       };
70715     }
70716   }
70717 }
70718
70719
70720 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70721   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70722   unsigned int arg2 ;
70723
70724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70725   arg2 = (unsigned int)jarg2;
70726   {
70727     try {
70728       (arg1)->RemoveLayout(arg2);
70729     } catch (std::out_of_range& e) {
70730       {
70731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70732       };
70733     } catch (std::exception& e) {
70734       {
70735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70736       };
70737     } catch (...) {
70738       {
70739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70740       };
70741     }
70742   }
70743 }
70744
70745
70746 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70747   void * jresult ;
70748   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70749   unsigned int arg2 ;
70750   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70751
70752   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70753   arg2 = (unsigned int)jarg2;
70754   {
70755     try {
70756       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70757     } catch (std::out_of_range& e) {
70758       {
70759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70760       };
70761     } catch (std::exception& e) {
70762       {
70763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70764       };
70765     } catch (...) {
70766       {
70767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70768       };
70769     }
70770   }
70771   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70772   return jresult;
70773 }
70774
70775
70776 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetActiveLayout(void * jarg1) {
70777   void * jresult ;
70778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70779   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70780
70781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70782   {
70783     try {
70784       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70785     } catch (std::out_of_range& e) {
70786       {
70787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70788       };
70789     } catch (std::exception& e) {
70790       {
70791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (...) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70796       };
70797     }
70798   }
70799   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70800   return jresult;
70801 }
70802
70803
70804 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70805   float jresult ;
70806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70807   Dali::Toolkit::ItemId arg2 ;
70808   float result;
70809
70810   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70811   arg2 = (Dali::Toolkit::ItemId)jarg2;
70812   {
70813     try {
70814       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70815     } catch (std::out_of_range& e) {
70816       {
70817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70818       };
70819     } catch (std::exception& e) {
70820       {
70821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70822       };
70823     } catch (...) {
70824       {
70825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70826       };
70827     }
70828   }
70829   jresult = result;
70830   return jresult;
70831 }
70832
70833
70834 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70835   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70836   unsigned int arg2 ;
70837   Dali::Vector3 arg3 ;
70838   float arg4 ;
70839   Dali::Vector3 *argp3 ;
70840
70841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70842   arg2 = (unsigned int)jarg2;
70843   argp3 = (Dali::Vector3 *)jarg3;
70844   if (!argp3) {
70845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70846     return ;
70847   }
70848   arg3 = *argp3;
70849   arg4 = (float)jarg4;
70850   {
70851     try {
70852       (arg1)->ActivateLayout(arg2,arg3,arg4);
70853     } catch (std::out_of_range& e) {
70854       {
70855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70856       };
70857     } catch (std::exception& e) {
70858       {
70859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70860       };
70861     } catch (...) {
70862       {
70863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70864       };
70865     }
70866   }
70867 }
70868
70869
70870 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_DeactivateCurrentLayout(void * jarg1) {
70871   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70872
70873   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70874   {
70875     try {
70876       (arg1)->DeactivateCurrentLayout();
70877     } catch (std::out_of_range& e) {
70878       {
70879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70880       };
70881     } catch (std::exception& e) {
70882       {
70883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70884       };
70885     } catch (...) {
70886       {
70887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70888       };
70889     }
70890   }
70891 }
70892
70893
70894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70895   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70896   float arg2 ;
70897
70898   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70899   arg2 = (float)jarg2;
70900   {
70901     try {
70902       (arg1)->SetMinimumSwipeSpeed(arg2);
70903     } catch (std::out_of_range& e) {
70904       {
70905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70906       };
70907     } catch (std::exception& e) {
70908       {
70909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70910       };
70911     } catch (...) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70914       };
70915     }
70916   }
70917 }
70918
70919
70920 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70921   float jresult ;
70922   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70923   float result;
70924
70925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70926   {
70927     try {
70928       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70929     } catch (std::out_of_range& e) {
70930       {
70931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70932       };
70933     } catch (std::exception& e) {
70934       {
70935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70936       };
70937     } catch (...) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70940       };
70941     }
70942   }
70943   jresult = result;
70944   return jresult;
70945 }
70946
70947
70948 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70949   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70950   float arg2 ;
70951
70952   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70953   arg2 = (float)jarg2;
70954   {
70955     try {
70956       (arg1)->SetMinimumSwipeDistance(arg2);
70957     } catch (std::out_of_range& e) {
70958       {
70959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70960       };
70961     } catch (std::exception& e) {
70962       {
70963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70964       };
70965     } catch (...) {
70966       {
70967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70968       };
70969     }
70970   }
70971 }
70972
70973
70974 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70975   float jresult ;
70976   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70977   float result;
70978
70979   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70980   {
70981     try {
70982       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70983     } catch (std::out_of_range& e) {
70984       {
70985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70986       };
70987     } catch (std::exception& e) {
70988       {
70989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70990       };
70991     } catch (...) {
70992       {
70993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70994       };
70995     }
70996   }
70997   jresult = result;
70998   return jresult;
70999 }
71000
71001
71002 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71003   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71004   float arg2 ;
71005
71006   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71007   arg2 = (float)jarg2;
71008   {
71009     try {
71010       (arg1)->SetWheelScrollDistanceStep(arg2);
71011     } catch (std::out_of_range& e) {
71012       {
71013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71014       };
71015     } catch (std::exception& e) {
71016       {
71017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71018       };
71019     } catch (...) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71022       };
71023     }
71024   }
71025 }
71026
71027
71028 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71029   float jresult ;
71030   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71031   float result;
71032
71033   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71034   {
71035     try {
71036       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71037     } catch (std::out_of_range& e) {
71038       {
71039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (std::exception& e) {
71042       {
71043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71044       };
71045     } catch (...) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71048       };
71049     }
71050   }
71051   jresult = result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71057   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71058   bool arg2 ;
71059
71060   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71061   arg2 = jarg2 ? true : false;
71062   {
71063     try {
71064       (arg1)->SetAnchoring(arg2);
71065     } catch (std::out_of_range& e) {
71066       {
71067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71068       };
71069     } catch (std::exception& e) {
71070       {
71071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71072       };
71073     } catch (...) {
71074       {
71075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71076       };
71077     }
71078   }
71079 }
71080
71081
71082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetAnchoring(void * jarg1) {
71083   unsigned int jresult ;
71084   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71085   bool result;
71086
71087   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71088   {
71089     try {
71090       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71091     } catch (std::out_of_range& e) {
71092       {
71093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71094       };
71095     } catch (std::exception& e) {
71096       {
71097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71098       };
71099     } catch (...) {
71100       {
71101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71102       };
71103     }
71104   }
71105   jresult = result;
71106   return jresult;
71107 }
71108
71109
71110 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71111   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71112   float arg2 ;
71113
71114   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71115   arg2 = (float)jarg2;
71116   {
71117     try {
71118       (arg1)->SetAnchoringDuration(arg2);
71119     } catch (std::out_of_range& e) {
71120       {
71121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71122       };
71123     } catch (std::exception& e) {
71124       {
71125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71126       };
71127     } catch (...) {
71128       {
71129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71130       };
71131     }
71132   }
71133 }
71134
71135
71136 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetAnchoringDuration(void * jarg1) {
71137   float jresult ;
71138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71139   float result;
71140
71141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71142   {
71143     try {
71144       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71145     } catch (std::out_of_range& e) {
71146       {
71147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71148       };
71149     } catch (std::exception& e) {
71150       {
71151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (...) {
71154       {
71155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71156       };
71157     }
71158   }
71159   jresult = result;
71160   return jresult;
71161 }
71162
71163
71164 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71165   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71166   Dali::Toolkit::ItemId arg2 ;
71167   float arg3 ;
71168
71169   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71170   arg2 = (Dali::Toolkit::ItemId)jarg2;
71171   arg3 = (float)jarg3;
71172   {
71173     try {
71174       (arg1)->ScrollToItem(arg2,arg3);
71175     } catch (std::out_of_range& e) {
71176       {
71177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71178       };
71179     } catch (std::exception& e) {
71180       {
71181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71182       };
71183     } catch (...) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71186       };
71187     }
71188   }
71189 }
71190
71191
71192 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71193   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71194   float arg2 ;
71195
71196   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71197   arg2 = (float)jarg2;
71198   {
71199     try {
71200       (arg1)->SetRefreshInterval(arg2);
71201     } catch (std::out_of_range& e) {
71202       {
71203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71204       };
71205     } catch (std::exception& e) {
71206       {
71207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71208       };
71209     } catch (...) {
71210       {
71211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71212       };
71213     }
71214   }
71215 }
71216
71217
71218 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ItemView_GetRefreshInterval(void * jarg1) {
71219   float jresult ;
71220   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71221   float result;
71222
71223   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71224   {
71225     try {
71226       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71227     } catch (std::out_of_range& e) {
71228       {
71229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71230       };
71231     } catch (std::exception& e) {
71232       {
71233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71234       };
71235     } catch (...) {
71236       {
71237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71238       };
71239     }
71240   }
71241   jresult = result;
71242   return jresult;
71243 }
71244
71245
71246 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_Refresh(void * jarg1) {
71247   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71248
71249   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71250   {
71251     try {
71252       (arg1)->Refresh();
71253     } catch (std::out_of_range& e) {
71254       {
71255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71256       };
71257     } catch (std::exception& e) {
71258       {
71259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71260       };
71261     } catch (...) {
71262       {
71263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71264       };
71265     }
71266   }
71267 }
71268
71269
71270 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71271   void * jresult ;
71272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71273   Dali::Toolkit::ItemId arg2 ;
71274   Dali::Actor result;
71275
71276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71277   arg2 = (Dali::Toolkit::ItemId)jarg2;
71278   {
71279     try {
71280       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71281     } catch (std::out_of_range& e) {
71282       {
71283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71284       };
71285     } catch (std::exception& e) {
71286       {
71287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71288       };
71289     } catch (...) {
71290       {
71291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71292       };
71293     }
71294   }
71295   jresult = new Dali::Actor((const Dali::Actor &)result);
71296   return jresult;
71297 }
71298
71299
71300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemView_GetItemId(void * jarg1, void * jarg2) {
71301   unsigned int jresult ;
71302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71303   Dali::Actor arg2 ;
71304   Dali::Actor *argp2 ;
71305   Dali::Toolkit::ItemId result;
71306
71307   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71308   argp2 = (Dali::Actor *)jarg2;
71309   if (!argp2) {
71310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71311     return 0;
71312   }
71313   arg2 = *argp2;
71314   {
71315     try {
71316       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71317     } catch (std::out_of_range& e) {
71318       {
71319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71320       };
71321     } catch (std::exception& e) {
71322       {
71323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71324       };
71325     } catch (...) {
71326       {
71327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71328       };
71329     }
71330   }
71331   jresult = result;
71332   return jresult;
71333 }
71334
71335
71336 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71337   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71338   Dali::Toolkit::Item arg2 ;
71339   float arg3 ;
71340   Dali::Toolkit::Item *argp2 ;
71341
71342   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71343   argp2 = (Dali::Toolkit::Item *)jarg2;
71344   if (!argp2) {
71345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71346     return ;
71347   }
71348   arg2 = *argp2;
71349   arg3 = (float)jarg3;
71350   {
71351     try {
71352       (arg1)->InsertItem(arg2,arg3);
71353     } catch (std::out_of_range& e) {
71354       {
71355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71356       };
71357     } catch (std::exception& e) {
71358       {
71359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71360       };
71361     } catch (...) {
71362       {
71363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71364       };
71365     }
71366   }
71367 }
71368
71369
71370 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71371   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71372   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71373   float arg3 ;
71374
71375   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71376   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71377   if (!arg2) {
71378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71379     return ;
71380   }
71381   arg3 = (float)jarg3;
71382   {
71383     try {
71384       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71385     } catch (std::out_of_range& e) {
71386       {
71387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71388       };
71389     } catch (std::exception& e) {
71390       {
71391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71392       };
71393     } catch (...) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71396       };
71397     }
71398   }
71399 }
71400
71401
71402 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71403   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71404   Dali::Toolkit::ItemId arg2 ;
71405   float arg3 ;
71406
71407   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71408   arg2 = (Dali::Toolkit::ItemId)jarg2;
71409   arg3 = (float)jarg3;
71410   {
71411     try {
71412       (arg1)->RemoveItem(arg2,arg3);
71413     } catch (std::out_of_range& e) {
71414       {
71415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71416       };
71417     } catch (std::exception& e) {
71418       {
71419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71420       };
71421     } catch (...) {
71422       {
71423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71424       };
71425     }
71426   }
71427 }
71428
71429
71430 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71432   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71433   float arg3 ;
71434
71435   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71436   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71437   if (!arg2) {
71438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71439     return ;
71440   }
71441   arg3 = (float)jarg3;
71442   {
71443     try {
71444       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71445     } catch (std::out_of_range& e) {
71446       {
71447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71448       };
71449     } catch (std::exception& e) {
71450       {
71451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (...) {
71454       {
71455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71456       };
71457     }
71458   }
71459 }
71460
71461
71462 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71463   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71464   Dali::Toolkit::Item arg2 ;
71465   float arg3 ;
71466   Dali::Toolkit::Item *argp2 ;
71467
71468   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71469   argp2 = (Dali::Toolkit::Item *)jarg2;
71470   if (!argp2) {
71471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71472     return ;
71473   }
71474   arg2 = *argp2;
71475   arg3 = (float)jarg3;
71476   {
71477     try {
71478       (arg1)->ReplaceItem(arg2,arg3);
71479     } catch (std::out_of_range& e) {
71480       {
71481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71482       };
71483     } catch (std::exception& e) {
71484       {
71485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71486       };
71487     } catch (...) {
71488       {
71489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71490       };
71491     }
71492   }
71493 }
71494
71495
71496 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71497   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71498   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71499   float arg3 ;
71500
71501   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71502   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71503   if (!arg2) {
71504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71505     return ;
71506   }
71507   arg3 = (float)jarg3;
71508   {
71509     try {
71510       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71511     } catch (std::out_of_range& e) {
71512       {
71513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71514       };
71515     } catch (std::exception& e) {
71516       {
71517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71518       };
71519     } catch (...) {
71520       {
71521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71522       };
71523     }
71524   }
71525 }
71526
71527
71528 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71529   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71530   Dali::Vector3 *arg2 = 0 ;
71531
71532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71533   arg2 = (Dali::Vector3 *)jarg2;
71534   if (!arg2) {
71535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71536     return ;
71537   }
71538   {
71539     try {
71540       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71548       };
71549     } catch (...) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71552       };
71553     }
71554   }
71555 }
71556
71557
71558 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItemsParentOrigin(void * jarg1) {
71559   void * jresult ;
71560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71561   Dali::Vector3 result;
71562
71563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71564   {
71565     try {
71566       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71567     } catch (std::out_of_range& e) {
71568       {
71569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71570       };
71571     } catch (std::exception& e) {
71572       {
71573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71574       };
71575     } catch (...) {
71576       {
71577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71578       };
71579     }
71580   }
71581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71582   return jresult;
71583 }
71584
71585
71586 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71588   Dali::Vector3 *arg2 = 0 ;
71589
71590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71591   arg2 = (Dali::Vector3 *)jarg2;
71592   if (!arg2) {
71593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71594     return ;
71595   }
71596   {
71597     try {
71598       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71599     } catch (std::out_of_range& e) {
71600       {
71601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71602       };
71603     } catch (std::exception& e) {
71604       {
71605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71606       };
71607     } catch (...) {
71608       {
71609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71610       };
71611     }
71612   }
71613 }
71614
71615
71616 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_GetItemsAnchorPoint(void * jarg1) {
71617   void * jresult ;
71618   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71619   Dali::Vector3 result;
71620
71621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71622   {
71623     try {
71624       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71625     } catch (std::out_of_range& e) {
71626       {
71627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71628       };
71629     } catch (std::exception& e) {
71630       {
71631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71632       };
71633     } catch (...) {
71634       {
71635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71636       };
71637     }
71638   }
71639   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71640   return jresult;
71641 }
71642
71643
71644 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71645   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71646   Dali::Toolkit::ItemRange *arg2 = 0 ;
71647
71648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71649   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71650   if (!arg2) {
71651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71652     return ;
71653   }
71654   {
71655     try {
71656       (arg1)->GetItemsRange(*arg2);
71657     } catch (std::out_of_range& e) {
71658       {
71659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71660       };
71661     } catch (std::exception& e) {
71662       {
71663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71664       };
71665     } catch (...) {
71666       {
71667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71668       };
71669     }
71670   }
71671 }
71672
71673
71674 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemView_LayoutActivatedSignal(void * jarg1) {
71675   void * jresult ;
71676   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71677   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71678
71679   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71680   {
71681     try {
71682       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71683     } catch (std::out_of_range& e) {
71684       {
71685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71686       };
71687     } catch (std::exception& e) {
71688       {
71689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71690       };
71691     } catch (...) {
71692       {
71693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71694       };
71695     }
71696   }
71697   jresult = (void *)result;
71698   return jresult;
71699 }
71700
71701
71702 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_MoveActorConstraint(void * jarg1, void * jarg2) {
71703   Dali::Vector3 *arg1 = 0 ;
71704   PropertyInputContainer *arg2 = 0 ;
71705
71706   arg1 = (Dali::Vector3 *)jarg1;
71707   if (!arg1) {
71708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71709     return ;
71710   }
71711   arg2 = (PropertyInputContainer *)jarg2;
71712   if (!arg2) {
71713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71714     return ;
71715   }
71716   {
71717     try {
71718       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71719     } catch (std::out_of_range& e) {
71720       {
71721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71722       };
71723     } catch (std::exception& e) {
71724       {
71725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71726       };
71727     } catch (...) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71730       };
71731     }
71732   }
71733 }
71734
71735
71736 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_WrapActorConstraint(void * jarg1, void * jarg2) {
71737   Dali::Vector3 *arg1 = 0 ;
71738   PropertyInputContainer *arg2 = 0 ;
71739
71740   arg1 = (Dali::Vector3 *)jarg1;
71741   if (!arg1) {
71742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71743     return ;
71744   }
71745   arg2 = (PropertyInputContainer *)jarg2;
71746   if (!arg2) {
71747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71748     return ;
71749   }
71750   {
71751     try {
71752       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71753     } catch (std::out_of_range& e) {
71754       {
71755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71756       };
71757     } catch (std::exception& e) {
71758       {
71759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71760       };
71761     } catch (...) {
71762       {
71763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71764       };
71765     }
71766   }
71767 }
71768
71769
71770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewEffect() {
71771   void * jresult ;
71772   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71773
71774   {
71775     try {
71776       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71777     } catch (std::out_of_range& e) {
71778       {
71779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71780       };
71781     } catch (std::exception& e) {
71782       {
71783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71784       };
71785     } catch (...) {
71786       {
71787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71788       };
71789     }
71790   }
71791   jresult = (void *)result;
71792   return jresult;
71793 }
71794
71795
71796 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewEffect(void * jarg1) {
71797   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71798
71799   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71800   {
71801     try {
71802       delete arg1;
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71810       };
71811     } catch (...) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71814       };
71815     }
71816   }
71817 }
71818
71819
71820 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71821   void * jresult ;
71822   Dali::Path arg1 ;
71823   Dali::Vector3 *arg2 = 0 ;
71824   Dali::Property::Index arg3 ;
71825   Dali::Vector3 *arg4 = 0 ;
71826   unsigned int arg5 ;
71827   Dali::Path *argp1 ;
71828   Dali::Toolkit::ScrollViewPagePathEffect result;
71829
71830   argp1 = (Dali::Path *)jarg1;
71831   if (!argp1) {
71832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71833     return 0;
71834   }
71835   arg1 = *argp1;
71836   arg2 = (Dali::Vector3 *)jarg2;
71837   if (!arg2) {
71838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71839     return 0;
71840   }
71841   arg3 = (Dali::Property::Index)jarg3;
71842   arg4 = (Dali::Vector3 *)jarg4;
71843   if (!arg4) {
71844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71845     return 0;
71846   }
71847   arg5 = (unsigned int)jarg5;
71848   {
71849     try {
71850       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (...) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71862       };
71863     }
71864   }
71865   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71866   return jresult;
71867 }
71868
71869
71870 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewPagePathEffect() {
71871   void * jresult ;
71872   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71873
71874   {
71875     try {
71876       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71877     } catch (std::out_of_range& e) {
71878       {
71879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71880       };
71881     } catch (std::exception& e) {
71882       {
71883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71884       };
71885     } catch (...) {
71886       {
71887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71888       };
71889     }
71890   }
71891   jresult = (void *)result;
71892   return jresult;
71893 }
71894
71895
71896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71897   void * jresult ;
71898   Dali::BaseHandle arg1 ;
71899   Dali::BaseHandle *argp1 ;
71900   Dali::Toolkit::ScrollViewPagePathEffect result;
71901
71902   argp1 = (Dali::BaseHandle *)jarg1;
71903   if (!argp1) {
71904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71905     return 0;
71906   }
71907   arg1 = *argp1;
71908   {
71909     try {
71910       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71911     } catch (std::out_of_range& e) {
71912       {
71913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71914       };
71915     } catch (std::exception& e) {
71916       {
71917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71918       };
71919     } catch (...) {
71920       {
71921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71922       };
71923     }
71924   }
71925   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71926   return jresult;
71927 }
71928
71929
71930 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71931   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71932   Dali::Actor arg2 ;
71933   unsigned int arg3 ;
71934   Dali::Actor *argp2 ;
71935
71936   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71937   argp2 = (Dali::Actor *)jarg2;
71938   if (!argp2) {
71939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71940     return ;
71941   }
71942   arg2 = *argp2;
71943   arg3 = (unsigned int)jarg3;
71944   {
71945     try {
71946       (arg1)->ApplyToPage(arg2,arg3);
71947     } catch (std::out_of_range& e) {
71948       {
71949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71950       };
71951     } catch (std::exception& e) {
71952       {
71953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71954       };
71955     } catch (...) {
71956       {
71957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71958       };
71959     }
71960   }
71961 }
71962
71963
71964 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewPagePathEffect(void * jarg1) {
71965   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71966
71967   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71968   {
71969     try {
71970       delete arg1;
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71982       };
71983     }
71984   }
71985 }
71986
71987
71988 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ClampState2D_x_set(void * jarg1, int jarg2) {
71989   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71990   Dali::Toolkit::ClampState arg2 ;
71991
71992   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71993   arg2 = (Dali::Toolkit::ClampState)jarg2;
71994   if (arg1) (arg1)->x = arg2;
71995 }
71996
71997
71998 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ClampState2D_x_get(void * jarg1) {
71999   int jresult ;
72000   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72001   Dali::Toolkit::ClampState result;
72002
72003   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72004   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72005   jresult = (int)result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ClampState2D_y_set(void * jarg1, int jarg2) {
72011   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72012   Dali::Toolkit::ClampState arg2 ;
72013
72014   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72015   arg2 = (Dali::Toolkit::ClampState)jarg2;
72016   if (arg1) (arg1)->y = arg2;
72017 }
72018
72019
72020 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ClampState2D_y_get(void * jarg1) {
72021   int jresult ;
72022   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72023   Dali::Toolkit::ClampState result;
72024
72025   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72026   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72027   jresult = (int)result;
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ClampState2D() {
72033   void * jresult ;
72034   Dali::Toolkit::ClampState2D *result = 0 ;
72035
72036   {
72037     try {
72038       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72039     } catch (std::out_of_range& e) {
72040       {
72041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72042       };
72043     } catch (std::exception& e) {
72044       {
72045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72046       };
72047     } catch (...) {
72048       {
72049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72050       };
72051     }
72052   }
72053   jresult = (void *)result;
72054   return jresult;
72055 }
72056
72057
72058 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ClampState2D(void * jarg1) {
72059   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72060
72061   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72062   {
72063     try {
72064       delete arg1;
72065     } catch (std::out_of_range& e) {
72066       {
72067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72068       };
72069     } catch (std::exception& e) {
72070       {
72071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72072       };
72073     } catch (...) {
72074       {
72075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72076       };
72077     }
72078   }
72079 }
72080
72081
72082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72083   void * jresult ;
72084   float arg1 ;
72085   float arg2 ;
72086   bool arg3 ;
72087   Dali::Toolkit::RulerDomain *result = 0 ;
72088
72089   arg1 = (float)jarg1;
72090   arg2 = (float)jarg2;
72091   arg3 = jarg3 ? true : false;
72092   {
72093     try {
72094       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72095     } catch (std::out_of_range& e) {
72096       {
72097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72098       };
72099     } catch (std::exception& e) {
72100       {
72101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (...) {
72104       {
72105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72106       };
72107     }
72108   }
72109   jresult = (void *)result;
72110   return jresult;
72111 }
72112
72113
72114 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72115   void * jresult ;
72116   float arg1 ;
72117   float arg2 ;
72118   Dali::Toolkit::RulerDomain *result = 0 ;
72119
72120   arg1 = (float)jarg1;
72121   arg2 = (float)jarg2;
72122   {
72123     try {
72124       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72125     } catch (std::out_of_range& e) {
72126       {
72127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72128       };
72129     } catch (std::exception& e) {
72130       {
72131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72132       };
72133     } catch (...) {
72134       {
72135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72136       };
72137     }
72138   }
72139   jresult = (void *)result;
72140   return jresult;
72141 }
72142
72143
72144 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_min_set(void * jarg1, float jarg2) {
72145   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72146   float arg2 ;
72147
72148   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72149   arg2 = (float)jarg2;
72150   if (arg1) (arg1)->min = arg2;
72151 }
72152
72153
72154 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_min_get(void * jarg1) {
72155   float jresult ;
72156   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72157   float result;
72158
72159   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72160   result = (float) ((arg1)->min);
72161   jresult = result;
72162   return jresult;
72163 }
72164
72165
72166 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_max_set(void * jarg1, float jarg2) {
72167   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72168   float arg2 ;
72169
72170   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72171   arg2 = (float)jarg2;
72172   if (arg1) (arg1)->max = arg2;
72173 }
72174
72175
72176 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_max_get(void * jarg1) {
72177   float jresult ;
72178   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72179   float result;
72180
72181   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72182   result = (float) ((arg1)->max);
72183   jresult = result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72189   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72190   bool arg2 ;
72191
72192   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72193   arg2 = jarg2 ? true : false;
72194   if (arg1) (arg1)->enabled = arg2;
72195 }
72196
72197
72198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerDomain_enabled_get(void * jarg1) {
72199   unsigned int jresult ;
72200   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72201   bool result;
72202
72203   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72204   result = (bool) ((arg1)->enabled);
72205   jresult = result;
72206   return jresult;
72207 }
72208
72209
72210 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72211   float jresult ;
72212   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72213   float arg2 ;
72214   float arg3 ;
72215   float arg4 ;
72216   float result;
72217
72218   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72219   arg2 = (float)jarg2;
72220   arg3 = (float)jarg3;
72221   arg4 = (float)jarg4;
72222   {
72223     try {
72224       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72225     } catch (std::out_of_range& e) {
72226       {
72227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72228       };
72229     } catch (std::exception& e) {
72230       {
72231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72232       };
72233     } catch (...) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72236       };
72237     }
72238   }
72239   jresult = result;
72240   return jresult;
72241 }
72242
72243
72244 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72245   float jresult ;
72246   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72247   float arg2 ;
72248   float arg3 ;
72249   float result;
72250
72251   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72252   arg2 = (float)jarg2;
72253   arg3 = (float)jarg3;
72254   {
72255     try {
72256       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72257     } catch (std::out_of_range& e) {
72258       {
72259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72260       };
72261     } catch (std::exception& e) {
72262       {
72263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72264       };
72265     } catch (...) {
72266       {
72267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72268       };
72269     }
72270   }
72271   jresult = result;
72272   return jresult;
72273 }
72274
72275
72276 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72277   float jresult ;
72278   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72279   float arg2 ;
72280   float result;
72281
72282   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72283   arg2 = (float)jarg2;
72284   {
72285     try {
72286       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72287     } catch (std::out_of_range& e) {
72288       {
72289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72290       };
72291     } catch (std::exception& e) {
72292       {
72293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (...) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72298       };
72299     }
72300   }
72301   jresult = result;
72302   return jresult;
72303 }
72304
72305
72306 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72307   float jresult ;
72308   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72309   float arg2 ;
72310   float arg3 ;
72311   float arg4 ;
72312   Dali::Toolkit::ClampState *arg5 = 0 ;
72313   float result;
72314
72315   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72316   arg2 = (float)jarg2;
72317   arg3 = (float)jarg3;
72318   arg4 = (float)jarg4;
72319   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72320   if (!arg5) {
72321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72322     return 0;
72323   }
72324   {
72325     try {
72326       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72327     } catch (std::out_of_range& e) {
72328       {
72329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72330       };
72331     } catch (std::exception& e) {
72332       {
72333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72334       };
72335     } catch (...) {
72336       {
72337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72338       };
72339     }
72340   }
72341   jresult = result;
72342   return jresult;
72343 }
72344
72345
72346 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerDomain_GetSize(void * jarg1) {
72347   float jresult ;
72348   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72349   float result;
72350
72351   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72352   {
72353     try {
72354       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72355     } catch (std::out_of_range& e) {
72356       {
72357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72358       };
72359     } catch (std::exception& e) {
72360       {
72361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72362       };
72363     } catch (...) {
72364       {
72365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72366       };
72367     }
72368   }
72369   jresult = result;
72370   return jresult;
72371 }
72372
72373
72374 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RulerDomain(void * jarg1) {
72375   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72376
72377   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72378   {
72379     try {
72380       delete arg1;
72381     } catch (std::out_of_range& e) {
72382       {
72383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72384       };
72385     } catch (std::exception& e) {
72386       {
72387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72388       };
72389     } catch (...) {
72390       {
72391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72392       };
72393     }
72394   }
72395 }
72396
72397
72398 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72399   float jresult ;
72400   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72401   float arg2 ;
72402   float arg3 ;
72403   float result;
72404
72405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72406   arg2 = (float)jarg2;
72407   arg3 = (float)jarg3;
72408   {
72409     try {
72410       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72411     } catch (std::out_of_range& e) {
72412       {
72413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (std::exception& e) {
72416       {
72417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72418       };
72419     } catch (...) {
72420       {
72421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72422       };
72423     }
72424   }
72425   jresult = result;
72426   return jresult;
72427 }
72428
72429
72430 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72431   float jresult ;
72432   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72433   float arg2 ;
72434   float result;
72435
72436   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72437   arg2 = (float)jarg2;
72438   {
72439     try {
72440       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72441     } catch (std::out_of_range& e) {
72442       {
72443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72444       };
72445     } catch (std::exception& e) {
72446       {
72447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72448       };
72449     } catch (...) {
72450       {
72451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72452       };
72453     }
72454   }
72455   jresult = result;
72456   return jresult;
72457 }
72458
72459
72460 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72461   float jresult ;
72462   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72463   unsigned int arg2 ;
72464   unsigned int *arg3 = 0 ;
72465   bool arg4 ;
72466   float result;
72467
72468   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72469   arg2 = (unsigned int)jarg2;
72470   arg3 = (unsigned int *)jarg3;
72471   arg4 = jarg4 ? true : false;
72472   {
72473     try {
72474       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72475     } catch (std::out_of_range& e) {
72476       {
72477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72478       };
72479     } catch (std::exception& e) {
72480       {
72481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72482       };
72483     } catch (...) {
72484       {
72485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72486       };
72487     }
72488   }
72489   jresult = result;
72490   return jresult;
72491 }
72492
72493
72494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72495   unsigned int jresult ;
72496   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72497   float arg2 ;
72498   bool arg3 ;
72499   unsigned int result;
72500
72501   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72502   arg2 = (float)jarg2;
72503   arg3 = jarg3 ? true : false;
72504   {
72505     try {
72506       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72507     } catch (std::out_of_range& e) {
72508       {
72509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72510       };
72511     } catch (std::exception& e) {
72512       {
72513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72514       };
72515     } catch (...) {
72516       {
72517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72518       };
72519     }
72520   }
72521   jresult = result;
72522   return jresult;
72523 }
72524
72525
72526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_GetTotalPages(void * jarg1) {
72527   unsigned int jresult ;
72528   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72529   unsigned int result;
72530
72531   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72532   {
72533     try {
72534       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72535     } catch (std::out_of_range& e) {
72536       {
72537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72538       };
72539     } catch (std::exception& e) {
72540       {
72541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72542       };
72543     } catch (...) {
72544       {
72545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72546       };
72547     }
72548   }
72549   jresult = result;
72550   return jresult;
72551 }
72552
72553
72554 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Ruler_GetType(void * jarg1) {
72555   int jresult ;
72556   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72557   Dali::Toolkit::Ruler::RulerType result;
72558
72559   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72560   {
72561     try {
72562       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72563     } catch (std::out_of_range& e) {
72564       {
72565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72566       };
72567     } catch (std::exception& e) {
72568       {
72569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72570       };
72571     } catch (...) {
72572       {
72573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72574       };
72575     }
72576   }
72577   jresult = (int)result;
72578   return jresult;
72579 }
72580
72581
72582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Ruler_IsEnabled(void * jarg1) {
72583   unsigned int jresult ;
72584   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72585   bool result;
72586
72587   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72588   {
72589     try {
72590       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72591     } catch (std::out_of_range& e) {
72592       {
72593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (std::exception& e) {
72596       {
72597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (...) {
72600       {
72601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72602       };
72603     }
72604   }
72605   jresult = result;
72606   return jresult;
72607 }
72608
72609
72610 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_Enable(void * jarg1) {
72611   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72612
72613   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72614   {
72615     try {
72616       (arg1)->Enable();
72617     } catch (std::out_of_range& e) {
72618       {
72619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72620       };
72621     } catch (std::exception& e) {
72622       {
72623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72624       };
72625     } catch (...) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72628       };
72629     }
72630   }
72631 }
72632
72633
72634 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_Disable(void * jarg1) {
72635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72636
72637   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72638   {
72639     try {
72640       (arg1)->Disable();
72641     } catch (std::out_of_range& e) {
72642       {
72643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72644       };
72645     } catch (std::exception& e) {
72646       {
72647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72648       };
72649     } catch (...) {
72650       {
72651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72652       };
72653     }
72654   }
72655 }
72656
72657
72658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_SetDomain(void * jarg1, void * jarg2) {
72659   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72660   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72661   Dali::Toolkit::RulerDomain *argp2 ;
72662
72663   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72664   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72665   if (!argp2) {
72666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72667     return ;
72668   }
72669   arg2 = *argp2;
72670   {
72671     try {
72672       (arg1)->SetDomain(arg2);
72673     } catch (std::out_of_range& e) {
72674       {
72675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72676       };
72677     } catch (std::exception& e) {
72678       {
72679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72680       };
72681     } catch (...) {
72682       {
72683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72684       };
72685     }
72686   }
72687 }
72688
72689
72690 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Ruler_GetDomain(void * jarg1) {
72691   void * jresult ;
72692   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72693   Dali::Toolkit::RulerDomain *result = 0 ;
72694
72695   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72696   {
72697     try {
72698       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72699     } catch (std::out_of_range& e) {
72700       {
72701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72702       };
72703     } catch (std::exception& e) {
72704       {
72705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72706       };
72707     } catch (...) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72710       };
72711     }
72712   }
72713   jresult = (void *)result;
72714   return jresult;
72715 }
72716
72717
72718 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Ruler_DisableDomain(void * jarg1) {
72719   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72720
72721   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72722   {
72723     try {
72724       (arg1)->DisableDomain();
72725     } catch (std::out_of_range& e) {
72726       {
72727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72728       };
72729     } catch (std::exception& e) {
72730       {
72731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72732       };
72733     } catch (...) {
72734       {
72735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72736       };
72737     }
72738   }
72739 }
72740
72741
72742 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72743   float jresult ;
72744   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72745   float arg2 ;
72746   float arg3 ;
72747   float arg4 ;
72748   float result;
72749
72750   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72751   arg2 = (float)jarg2;
72752   arg3 = (float)jarg3;
72753   arg4 = (float)jarg4;
72754   {
72755     try {
72756       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72757     } catch (std::out_of_range& e) {
72758       {
72759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72760       };
72761     } catch (std::exception& e) {
72762       {
72763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72764       };
72765     } catch (...) {
72766       {
72767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72768       };
72769     }
72770   }
72771   jresult = result;
72772   return jresult;
72773 }
72774
72775
72776 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72777   float jresult ;
72778   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72779   float arg2 ;
72780   float arg3 ;
72781   float result;
72782
72783   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72784   arg2 = (float)jarg2;
72785   arg3 = (float)jarg3;
72786   {
72787     try {
72788       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72789     } catch (std::out_of_range& e) {
72790       {
72791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72792       };
72793     } catch (std::exception& e) {
72794       {
72795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72796       };
72797     } catch (...) {
72798       {
72799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72800       };
72801     }
72802   }
72803   jresult = result;
72804   return jresult;
72805 }
72806
72807
72808 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72809   float jresult ;
72810   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72811   float arg2 ;
72812   float result;
72813
72814   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72815   arg2 = (float)jarg2;
72816   {
72817     try {
72818       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72819     } catch (std::out_of_range& e) {
72820       {
72821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72822       };
72823     } catch (std::exception& e) {
72824       {
72825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72826       };
72827     } catch (...) {
72828       {
72829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72830       };
72831     }
72832   }
72833   jresult = result;
72834   return jresult;
72835 }
72836
72837
72838 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72839   float jresult ;
72840   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72841   float arg2 ;
72842   float arg3 ;
72843   float arg4 ;
72844   Dali::Toolkit::ClampState *arg5 = 0 ;
72845   float result;
72846
72847   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72848   arg2 = (float)jarg2;
72849   arg3 = (float)jarg3;
72850   arg4 = (float)jarg4;
72851   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72852   if (!arg5) {
72853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72854     return 0;
72855   }
72856   {
72857     try {
72858       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72859     } catch (std::out_of_range& e) {
72860       {
72861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72862       };
72863     } catch (std::exception& e) {
72864       {
72865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72866       };
72867     } catch (...) {
72868       {
72869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72870       };
72871     }
72872   }
72873   jresult = result;
72874   return jresult;
72875 }
72876
72877
72878 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72879   float jresult ;
72880   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72881   float arg2 ;
72882   float arg3 ;
72883   float arg4 ;
72884   float arg5 ;
72885   float result;
72886
72887   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72888   arg2 = (float)jarg2;
72889   arg3 = (float)jarg3;
72890   arg4 = (float)jarg4;
72891   arg5 = (float)jarg5;
72892   {
72893     try {
72894       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909   jresult = result;
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72915   float jresult ;
72916   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72917   float arg2 ;
72918   float arg3 ;
72919   float arg4 ;
72920   float result;
72921
72922   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72923   arg2 = (float)jarg2;
72924   arg3 = (float)jarg3;
72925   arg4 = (float)jarg4;
72926   {
72927     try {
72928       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72929     } catch (std::out_of_range& e) {
72930       {
72931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72932       };
72933     } catch (std::exception& e) {
72934       {
72935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72936       };
72937     } catch (...) {
72938       {
72939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72940       };
72941     }
72942   }
72943   jresult = result;
72944   return jresult;
72945 }
72946
72947
72948 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72949   float jresult ;
72950   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72951   float arg2 ;
72952   float arg3 ;
72953   float result;
72954
72955   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72956   arg2 = (float)jarg2;
72957   arg3 = (float)jarg3;
72958   {
72959     try {
72960       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72961     } catch (std::out_of_range& e) {
72962       {
72963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (std::exception& e) {
72966       {
72967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (...) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72972       };
72973     }
72974   }
72975   jresult = result;
72976   return jresult;
72977 }
72978
72979
72980 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72981   float jresult ;
72982   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72983   float arg2 ;
72984   float result;
72985
72986   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72987   arg2 = (float)jarg2;
72988   {
72989     try {
72990       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72991     } catch (std::out_of_range& e) {
72992       {
72993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72994       };
72995     } catch (std::exception& e) {
72996       {
72997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73002       };
73003     }
73004   }
73005   jresult = result;
73006   return jresult;
73007 }
73008
73009
73010 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73011   float jresult ;
73012   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73013   float arg2 ;
73014   float arg3 ;
73015   float arg4 ;
73016   float arg5 ;
73017   Dali::Toolkit::ClampState *arg6 = 0 ;
73018   float result;
73019
73020   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73021   arg2 = (float)jarg2;
73022   arg3 = (float)jarg3;
73023   arg4 = (float)jarg4;
73024   arg5 = (float)jarg5;
73025   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73026   if (!arg6) {
73027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73028     return 0;
73029   }
73030   {
73031     try {
73032       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73033     } catch (std::out_of_range& e) {
73034       {
73035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (std::exception& e) {
73038       {
73039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (...) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73044       };
73045     }
73046   }
73047   jresult = result;
73048   return jresult;
73049 }
73050
73051
73052 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_DefaultRuler() {
73053   void * jresult ;
73054   Dali::Toolkit::DefaultRuler *result = 0 ;
73055
73056   {
73057     try {
73058       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73059     } catch (std::out_of_range& e) {
73060       {
73061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73062       };
73063     } catch (std::exception& e) {
73064       {
73065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73066       };
73067     } catch (...) {
73068       {
73069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73070       };
73071     }
73072   }
73073   jresult = (void *)result;
73074   return jresult;
73075 }
73076
73077
73078 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73079   float jresult ;
73080   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73081   float arg2 ;
73082   float arg3 ;
73083   float result;
73084
73085   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73086   arg2 = (float)jarg2;
73087   arg3 = (float)jarg3;
73088   {
73089     try {
73090       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73091     } catch (std::out_of_range& e) {
73092       {
73093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73094       };
73095     } catch (std::exception& e) {
73096       {
73097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73098       };
73099     } catch (...) {
73100       {
73101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73102       };
73103     }
73104   }
73105   jresult = result;
73106   return jresult;
73107 }
73108
73109
73110 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73111   float jresult ;
73112   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73113   unsigned int arg2 ;
73114   unsigned int *arg3 = 0 ;
73115   bool arg4 ;
73116   float result;
73117
73118   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73119   arg2 = (unsigned int)jarg2;
73120   arg3 = (unsigned int *)jarg3;
73121   arg4 = jarg4 ? true : false;
73122   {
73123     try {
73124       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73125     } catch (std::out_of_range& e) {
73126       {
73127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73128       };
73129     } catch (std::exception& e) {
73130       {
73131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73132       };
73133     } catch (...) {
73134       {
73135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73136       };
73137     }
73138   }
73139   jresult = result;
73140   return jresult;
73141 }
73142
73143
73144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73145   unsigned int jresult ;
73146   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73147   float arg2 ;
73148   bool arg3 ;
73149   unsigned int result;
73150
73151   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73152   arg2 = (float)jarg2;
73153   arg3 = jarg3 ? true : false;
73154   {
73155     try {
73156       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73157     } catch (std::out_of_range& e) {
73158       {
73159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73160       };
73161     } catch (std::exception& e) {
73162       {
73163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73164       };
73165     } catch (...) {
73166       {
73167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73168       };
73169     }
73170   }
73171   jresult = result;
73172   return jresult;
73173 }
73174
73175
73176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DefaultRuler_GetTotalPages(void * jarg1) {
73177   unsigned int jresult ;
73178   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73179   unsigned int result;
73180
73181   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73182   {
73183     try {
73184       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73185     } catch (std::out_of_range& e) {
73186       {
73187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (std::exception& e) {
73190       {
73191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (...) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73196       };
73197     }
73198   }
73199   jresult = result;
73200   return jresult;
73201 }
73202
73203
73204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_DefaultRuler(void * jarg1) {
73205   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73206
73207   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73208   {
73209     try {
73210       delete arg1;
73211     } catch (std::out_of_range& e) {
73212       {
73213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73214       };
73215     } catch (std::exception& e) {
73216       {
73217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73218       };
73219     } catch (...) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73222       };
73223     }
73224   }
73225 }
73226
73227
73228 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FixedRuler__SWIG_0(float jarg1) {
73229   void * jresult ;
73230   float arg1 ;
73231   Dali::Toolkit::FixedRuler *result = 0 ;
73232
73233   arg1 = (float)jarg1;
73234   {
73235     try {
73236       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73237     } catch (std::out_of_range& e) {
73238       {
73239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73240       };
73241     } catch (std::exception& e) {
73242       {
73243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73244       };
73245     } catch (...) {
73246       {
73247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73248       };
73249     }
73250   }
73251   jresult = (void *)result;
73252   return jresult;
73253 }
73254
73255
73256 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FixedRuler__SWIG_1() {
73257   void * jresult ;
73258   Dali::Toolkit::FixedRuler *result = 0 ;
73259
73260   {
73261     try {
73262       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73263     } catch (std::out_of_range& e) {
73264       {
73265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (std::exception& e) {
73268       {
73269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73270       };
73271     } catch (...) {
73272       {
73273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73274       };
73275     }
73276   }
73277   jresult = (void *)result;
73278   return jresult;
73279 }
73280
73281
73282 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73283   float jresult ;
73284   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73285   float arg2 ;
73286   float arg3 ;
73287   float result;
73288
73289   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73290   arg2 = (float)jarg2;
73291   arg3 = (float)jarg3;
73292   {
73293     try {
73294       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73295     } catch (std::out_of_range& e) {
73296       {
73297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73298       };
73299     } catch (std::exception& e) {
73300       {
73301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (...) {
73304       {
73305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73306       };
73307     }
73308   }
73309   jresult = result;
73310   return jresult;
73311 }
73312
73313
73314 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73315   float jresult ;
73316   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73317   unsigned int arg2 ;
73318   unsigned int *arg3 = 0 ;
73319   bool arg4 ;
73320   float result;
73321
73322   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73323   arg2 = (unsigned int)jarg2;
73324   arg3 = (unsigned int *)jarg3;
73325   arg4 = jarg4 ? true : false;
73326   {
73327     try {
73328       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73329     } catch (std::out_of_range& e) {
73330       {
73331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73332       };
73333     } catch (std::exception& e) {
73334       {
73335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73336       };
73337     } catch (...) {
73338       {
73339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73340       };
73341     }
73342   }
73343   jresult = result;
73344   return jresult;
73345 }
73346
73347
73348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73349   unsigned int jresult ;
73350   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73351   float arg2 ;
73352   bool arg3 ;
73353   unsigned int result;
73354
73355   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73356   arg2 = (float)jarg2;
73357   arg3 = jarg3 ? true : false;
73358   {
73359     try {
73360       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73361     } catch (std::out_of_range& e) {
73362       {
73363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73364       };
73365     } catch (std::exception& e) {
73366       {
73367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73368       };
73369     } catch (...) {
73370       {
73371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73372       };
73373     }
73374   }
73375   jresult = result;
73376   return jresult;
73377 }
73378
73379
73380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FixedRuler_GetTotalPages(void * jarg1) {
73381   unsigned int jresult ;
73382   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73383   unsigned int result;
73384
73385   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73386   {
73387     try {
73388       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73389     } catch (std::out_of_range& e) {
73390       {
73391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (std::exception& e) {
73394       {
73395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73396       };
73397     } catch (...) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73400       };
73401     }
73402   }
73403   jresult = result;
73404   return jresult;
73405 }
73406
73407
73408 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FixedRuler(void * jarg1) {
73409   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73410
73411   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73412   {
73413     try {
73414       delete arg1;
73415     } catch (std::out_of_range& e) {
73416       {
73417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73418       };
73419     } catch (std::exception& e) {
73420       {
73421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73422       };
73423     } catch (...) {
73424       {
73425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73426       };
73427     }
73428   }
73429 }
73430
73431
73432 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73433   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73434   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73435
73436   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73437   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73438   if (arg1) (arg1)->scale = *arg2;
73439 }
73440
73441
73442 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_scale_get(void * jarg1) {
73443   void * jresult ;
73444   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73445   Dali::Toolkit::ClampState2D *result = 0 ;
73446
73447   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73448   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73449   jresult = (void *)result;
73450   return jresult;
73451 }
73452
73453
73454 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73455   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73456   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73457
73458   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73459   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73460   if (arg1) (arg1)->position = *arg2;
73461 }
73462
73463
73464 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_position_get(void * jarg1) {
73465   void * jresult ;
73466   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73467   Dali::Toolkit::ClampState2D *result = 0 ;
73468
73469   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73470   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73471   jresult = (void *)result;
73472   return jresult;
73473 }
73474
73475
73476 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73477   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73478   Dali::Toolkit::ClampState arg2 ;
73479
73480   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73481   arg2 = (Dali::Toolkit::ClampState)jarg2;
73482   if (arg1) (arg1)->rotation = arg2;
73483 }
73484
73485
73486 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73487   int jresult ;
73488   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73489   Dali::Toolkit::ClampState result;
73490
73491   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73492   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73493   jresult = (int)result;
73494   return jresult;
73495 }
73496
73497
73498 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_ClampEvent() {
73499   void * jresult ;
73500   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73501
73502   {
73503     try {
73504       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73505     } catch (std::out_of_range& e) {
73506       {
73507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73508       };
73509     } catch (std::exception& e) {
73510       {
73511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73512       };
73513     } catch (...) {
73514       {
73515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73516       };
73517     }
73518   }
73519   jresult = (void *)result;
73520   return jresult;
73521 }
73522
73523
73524 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_ClampEvent(void * jarg1) {
73525   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73526
73527   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73528   {
73529     try {
73530       delete arg1;
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73542       };
73543     }
73544   }
73545 }
73546
73547
73548 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73549   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73550   Dali::Toolkit::SnapType arg2 ;
73551
73552   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73553   arg2 = (Dali::Toolkit::SnapType)jarg2;
73554   if (arg1) (arg1)->type = arg2;
73555 }
73556
73557
73558 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_type_get(void * jarg1) {
73559   int jresult ;
73560   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73561   Dali::Toolkit::SnapType result;
73562
73563   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73564   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73565   jresult = (int)result;
73566   return jresult;
73567 }
73568
73569
73570 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73571   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73572   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73573
73574   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73575   arg2 = (Dali::Vector2 *)jarg2;
73576   if (arg1) (arg1)->position = *arg2;
73577 }
73578
73579
73580 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_position_get(void * jarg1) {
73581   void * jresult ;
73582   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73583   Dali::Vector2 *result = 0 ;
73584
73585   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73586   result = (Dali::Vector2 *)& ((arg1)->position);
73587   jresult = (void *)result;
73588   return jresult;
73589 }
73590
73591
73592 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73593   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73594   float arg2 ;
73595
73596   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73597   arg2 = (float)jarg2;
73598   if (arg1) (arg1)->duration = arg2;
73599 }
73600
73601
73602 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_SnapEvent_duration_get(void * jarg1) {
73603   float jresult ;
73604   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73605   float result;
73606
73607   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73608   result = (float) ((arg1)->duration);
73609   jresult = result;
73610   return jresult;
73611 }
73612
73613
73614 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_SnapEvent() {
73615   void * jresult ;
73616   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73617
73618   {
73619     try {
73620       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73621     } catch (std::out_of_range& e) {
73622       {
73623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73624       };
73625     } catch (std::exception& e) {
73626       {
73627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73628       };
73629     } catch (...) {
73630       {
73631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73632       };
73633     }
73634   }
73635   jresult = (void *)result;
73636   return jresult;
73637 }
73638
73639
73640 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_SnapEvent(void * jarg1) {
73641   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73642
73643   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73644   {
73645     try {
73646       delete arg1;
73647     } catch (std::out_of_range& e) {
73648       {
73649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73650       };
73651     } catch (std::exception& e) {
73652       {
73653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73654       };
73655     } catch (...) {
73656       {
73657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73658       };
73659     }
73660   }
73661 }
73662
73663
73664 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WRAP_ENABLED_get() {
73665   int jresult ;
73666   int result;
73667
73668   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73669   jresult = (int)result;
73670   return jresult;
73671 }
73672
73673
73674 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_PANNING_ENABLED_get() {
73675   int jresult ;
73676   int result;
73677
73678   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73679   jresult = (int)result;
73680   return jresult;
73681 }
73682
73683
73684 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73685   int jresult ;
73686   int result;
73687
73688   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73689   jresult = (int)result;
73690   return jresult;
73691 }
73692
73693
73694 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73695   int jresult ;
73696   int result;
73697
73698   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73699   jresult = (int)result;
73700   return jresult;
73701 }
73702
73703
73704 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_POSITION_get() {
73705   int jresult ;
73706   int result;
73707
73708   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73709   jresult = (int)result;
73710   return jresult;
73711 }
73712
73713
73714 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73715   int jresult ;
73716   int result;
73717
73718   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73719   jresult = (int)result;
73720   return jresult;
73721 }
73722
73723
73724 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73725   int jresult ;
73726   int result;
73727
73728   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73729   jresult = (int)result;
73730   return jresult;
73731 }
73732
73733
73734 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73735   int jresult ;
73736   int result;
73737
73738   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73739   jresult = (int)result;
73740   return jresult;
73741 }
73742
73743
73744 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73745   int jresult ;
73746   int result;
73747
73748   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73749   jresult = (int)result;
73750   return jresult;
73751 }
73752
73753
73754 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73755   int jresult ;
73756   int result;
73757
73758   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73759   jresult = (int)result;
73760   return jresult;
73761 }
73762
73763
73764 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73765   int jresult ;
73766   int result;
73767
73768   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73769   jresult = (int)result;
73770   return jresult;
73771 }
73772
73773
73774 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_OVERSHOOT_X_get() {
73775   int jresult ;
73776   int result;
73777
73778   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73779   jresult = (int)result;
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_OVERSHOOT_Y_get() {
73785   int jresult ;
73786   int result;
73787
73788   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73789   jresult = (int)result;
73790   return jresult;
73791 }
73792
73793
73794 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_get() {
73795   int jresult ;
73796   int result;
73797
73798   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73799   jresult = (int)result;
73800   return jresult;
73801 }
73802
73803
73804 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_X_get() {
73805   int jresult ;
73806   int result;
73807
73808   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73809   jresult = (int)result;
73810   return jresult;
73811 }
73812
73813
73814 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_FINAL_Y_get() {
73815   int jresult ;
73816   int result;
73817
73818   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73819   jresult = (int)result;
73820   return jresult;
73821 }
73822
73823
73824 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_WRAP_get() {
73825   int jresult ;
73826   int result;
73827
73828   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73829   jresult = (int)result;
73830   return jresult;
73831 }
73832
73833
73834 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_PANNING_get() {
73835   int jresult ;
73836   int result;
73837
73838   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73839   jresult = (int)result;
73840   return jresult;
73841 }
73842
73843
73844 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLLING_get() {
73845   int jresult ;
73846   int result;
73847
73848   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73849   jresult = (int)result;
73850   return jresult;
73851 }
73852
73853
73854 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73855   int jresult ;
73856   int result;
73857
73858   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73859   jresult = (int)result;
73860   return jresult;
73861 }
73862
73863
73864 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73865   int jresult ;
73866   int result;
73867
73868   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73869   jresult = (int)result;
73870   return jresult;
73871 }
73872
73873
73874 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73875   int jresult ;
73876   int result;
73877
73878   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73879   jresult = (int)result;
73880   return jresult;
73881 }
73882
73883
73884 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73885   int jresult ;
73886   int result;
73887
73888   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73889   jresult = (int)result;
73890   return jresult;
73891 }
73892
73893
73894 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73895   int jresult ;
73896   int result;
73897
73898   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73899   jresult = (int)result;
73900   return jresult;
73901 }
73902
73903
73904 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_Property_START_PAGE_POSITION_get() {
73905   int jresult ;
73906   int result;
73907
73908   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73909   jresult = (int)result;
73910   return jresult;
73911 }
73912
73913
73914 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView_Property() {
73915   void * jresult ;
73916   Dali::Toolkit::ScrollView::Property *result = 0 ;
73917
73918   {
73919     try {
73920       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73921     } catch (std::out_of_range& e) {
73922       {
73923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73924       };
73925     } catch (std::exception& e) {
73926       {
73927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73928       };
73929     } catch (...) {
73930       {
73931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73932       };
73933     }
73934   }
73935   jresult = (void *)result;
73936   return jresult;
73937 }
73938
73939
73940 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView_Property(void * jarg1) {
73941   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73942
73943   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73944   {
73945     try {
73946       delete arg1;
73947     } catch (std::out_of_range& e) {
73948       {
73949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73950       };
73951     } catch (std::exception& e) {
73952       {
73953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73954       };
73955     } catch (...) {
73956       {
73957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73958       };
73959     }
73960   }
73961 }
73962
73963
73964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView__SWIG_0() {
73965   void * jresult ;
73966   Dali::Toolkit::ScrollView *result = 0 ;
73967
73968   {
73969     try {
73970       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73971     } catch (std::out_of_range& e) {
73972       {
73973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73974       };
73975     } catch (std::exception& e) {
73976       {
73977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73978       };
73979     } catch (...) {
73980       {
73981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73982       };
73983     }
73984   }
73985   jresult = (void *)result;
73986   return jresult;
73987 }
73988
73989
73990 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollView__SWIG_1(void * jarg1) {
73991   void * jresult ;
73992   Dali::Toolkit::ScrollView *arg1 = 0 ;
73993   Dali::Toolkit::ScrollView *result = 0 ;
73994
73995   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73996   if (!arg1) {
73997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73998     return 0;
73999   }
74000   {
74001     try {
74002       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74003     } catch (std::out_of_range& e) {
74004       {
74005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74006       };
74007     } catch (std::exception& e) {
74008       {
74009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74010       };
74011     } catch (...) {
74012       {
74013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74014       };
74015     }
74016   }
74017   jresult = (void *)result;
74018   return jresult;
74019 }
74020
74021
74022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_Assign(void * jarg1, void * jarg2) {
74023   void * jresult ;
74024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74025   Dali::Toolkit::ScrollView *arg2 = 0 ;
74026   Dali::Toolkit::ScrollView *result = 0 ;
74027
74028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74029   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74030   if (!arg2) {
74031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74032     return 0;
74033   }
74034   {
74035     try {
74036       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74037     } catch (std::out_of_range& e) {
74038       {
74039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74040       };
74041     } catch (std::exception& e) {
74042       {
74043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (...) {
74046       {
74047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74048       };
74049     }
74050   }
74051   jresult = (void *)result;
74052   return jresult;
74053 }
74054
74055
74056 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollView(void * jarg1) {
74057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74058
74059   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74060   {
74061     try {
74062       delete arg1;
74063     } catch (std::out_of_range& e) {
74064       {
74065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74066       };
74067     } catch (std::exception& e) {
74068       {
74069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74070       };
74071     } catch (...) {
74072       {
74073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74074       };
74075     }
74076   }
74077 }
74078
74079
74080 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_New() {
74081   void * jresult ;
74082   Dali::Toolkit::ScrollView result;
74083
74084   {
74085     try {
74086       result = Dali::Toolkit::ScrollView::New();
74087     } catch (std::out_of_range& e) {
74088       {
74089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (std::exception& e) {
74092       {
74093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_DownCast(void * jarg1) {
74107   void * jresult ;
74108   Dali::BaseHandle arg1 ;
74109   Dali::BaseHandle *argp1 ;
74110   Dali::Toolkit::ScrollView result;
74111
74112   argp1 = (Dali::BaseHandle *)jarg1;
74113   if (!argp1) {
74114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74115     return 0;
74116   }
74117   arg1 = *argp1;
74118   {
74119     try {
74120       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74132       };
74133     }
74134   }
74135   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74136   return jresult;
74137 }
74138
74139
74140 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74141   void * jresult ;
74142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74143   Dali::AlphaFunction result;
74144
74145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74146   {
74147     try {
74148       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74149     } catch (std::out_of_range& e) {
74150       {
74151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74152       };
74153     } catch (std::exception& e) {
74154       {
74155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74156       };
74157     } catch (...) {
74158       {
74159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74160       };
74161     }
74162   }
74163   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74164   return jresult;
74165 }
74166
74167
74168 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74170   Dali::AlphaFunction arg2 ;
74171   Dali::AlphaFunction *argp2 ;
74172
74173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74174   argp2 = (Dali::AlphaFunction *)jarg2;
74175   if (!argp2) {
74176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74177     return ;
74178   }
74179   arg2 = *argp2;
74180   {
74181     try {
74182       (arg1)->SetScrollSnapAlphaFunction(arg2);
74183     } catch (std::out_of_range& e) {
74184       {
74185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74186       };
74187     } catch (std::exception& e) {
74188       {
74189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74190       };
74191     } catch (...) {
74192       {
74193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74194       };
74195     }
74196   }
74197 }
74198
74199
74200 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74201   void * jresult ;
74202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74203   Dali::AlphaFunction result;
74204
74205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74206   {
74207     try {
74208       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74209     } catch (std::out_of_range& e) {
74210       {
74211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74212       };
74213     } catch (std::exception& e) {
74214       {
74215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74216       };
74217     } catch (...) {
74218       {
74219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74220       };
74221     }
74222   }
74223   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74224   return jresult;
74225 }
74226
74227
74228 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74229   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74230   Dali::AlphaFunction arg2 ;
74231   Dali::AlphaFunction *argp2 ;
74232
74233   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74234   argp2 = (Dali::AlphaFunction *)jarg2;
74235   if (!argp2) {
74236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74237     return ;
74238   }
74239   arg2 = *argp2;
74240   {
74241     try {
74242       (arg1)->SetScrollFlickAlphaFunction(arg2);
74243     } catch (std::out_of_range& e) {
74244       {
74245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74246       };
74247     } catch (std::exception& e) {
74248       {
74249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74250       };
74251     } catch (...) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74254       };
74255     }
74256   }
74257 }
74258
74259
74260 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollSnapDuration(void * jarg1) {
74261   float jresult ;
74262   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74263   float result;
74264
74265   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74266   {
74267     try {
74268       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74269     } catch (std::out_of_range& e) {
74270       {
74271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74272       };
74273     } catch (std::exception& e) {
74274       {
74275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74276       };
74277     } catch (...) {
74278       {
74279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74280       };
74281     }
74282   }
74283   jresult = result;
74284   return jresult;
74285 }
74286
74287
74288 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74290   float arg2 ;
74291
74292   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74293   arg2 = (float)jarg2;
74294   {
74295     try {
74296       (arg1)->SetScrollSnapDuration(arg2);
74297     } catch (std::out_of_range& e) {
74298       {
74299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74300       };
74301     } catch (std::exception& e) {
74302       {
74303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74304       };
74305     } catch (...) {
74306       {
74307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74308       };
74309     }
74310   }
74311 }
74312
74313
74314 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollFlickDuration(void * jarg1) {
74315   float jresult ;
74316   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74317   float result;
74318
74319   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74320   {
74321     try {
74322       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74323     } catch (std::out_of_range& e) {
74324       {
74325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74326       };
74327     } catch (std::exception& e) {
74328       {
74329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74330       };
74331     } catch (...) {
74332       {
74333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74334       };
74335     }
74336   }
74337   jresult = result;
74338   return jresult;
74339 }
74340
74341
74342 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74343   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74344   float arg2 ;
74345
74346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74347   arg2 = (float)jarg2;
74348   {
74349     try {
74350       (arg1)->SetScrollFlickDuration(arg2);
74351     } catch (std::out_of_range& e) {
74352       {
74353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74354       };
74355     } catch (std::exception& e) {
74356       {
74357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (...) {
74360       {
74361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74362       };
74363     }
74364   }
74365 }
74366
74367
74368 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74370   Dali::Toolkit::RulerPtr arg2 ;
74371   Dali::Toolkit::RulerPtr *argp2 ;
74372
74373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74374   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74375   if (!argp2) {
74376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74377     return ;
74378   }
74379   arg2 = *argp2;
74380   {
74381     try {
74382       (arg1)->SetRulerX(arg2);
74383     } catch (std::out_of_range& e) {
74384       {
74385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74386       };
74387     } catch (std::exception& e) {
74388       {
74389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74390       };
74391     } catch (...) {
74392       {
74393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74394       };
74395     }
74396   }
74397 }
74398
74399
74400 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74402   Dali::Toolkit::RulerPtr arg2 ;
74403   Dali::Toolkit::RulerPtr *argp2 ;
74404
74405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74406   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74407   if (!argp2) {
74408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74409     return ;
74410   }
74411   arg2 = *argp2;
74412   {
74413     try {
74414       (arg1)->SetRulerY(arg2);
74415     } catch (std::out_of_range& e) {
74416       {
74417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74418       };
74419     } catch (std::exception& e) {
74420       {
74421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74422       };
74423     } catch (...) {
74424       {
74425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74426       };
74427     }
74428   }
74429 }
74430
74431
74432 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74434   bool arg2 ;
74435
74436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74437   arg2 = jarg2 ? true : false;
74438   {
74439     try {
74440       (arg1)->SetScrollSensitive(arg2);
74441     } catch (std::out_of_range& e) {
74442       {
74443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74444       };
74445     } catch (std::exception& e) {
74446       {
74447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74448       };
74449     } catch (...) {
74450       {
74451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74452       };
74453     }
74454   }
74455 }
74456
74457
74458 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74460   float arg2 ;
74461   float arg3 ;
74462
74463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74464   arg2 = (float)jarg2;
74465   arg3 = (float)jarg3;
74466   {
74467     try {
74468       (arg1)->SetMaxOvershoot(arg2,arg3);
74469     } catch (std::out_of_range& e) {
74470       {
74471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74472       };
74473     } catch (std::exception& e) {
74474       {
74475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74476       };
74477     } catch (...) {
74478       {
74479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74480       };
74481     }
74482   }
74483 }
74484
74485
74486 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74488   Dali::AlphaFunction arg2 ;
74489   Dali::AlphaFunction *argp2 ;
74490
74491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74492   argp2 = (Dali::AlphaFunction *)jarg2;
74493   if (!argp2) {
74494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74495     return ;
74496   }
74497   arg2 = *argp2;
74498   {
74499     try {
74500       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74501     } catch (std::out_of_range& e) {
74502       {
74503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74504       };
74505     } catch (std::exception& e) {
74506       {
74507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74508       };
74509     } catch (...) {
74510       {
74511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74512       };
74513     }
74514   }
74515 }
74516
74517
74518 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74519   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74520   float arg2 ;
74521
74522   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74523   arg2 = (float)jarg2;
74524   {
74525     try {
74526       (arg1)->SetSnapOvershootDuration(arg2);
74527     } catch (std::out_of_range& e) {
74528       {
74529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74530       };
74531     } catch (std::exception& e) {
74532       {
74533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74534       };
74535     } catch (...) {
74536       {
74537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74538       };
74539     }
74540   }
74541 }
74542
74543
74544 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74546   bool arg2 ;
74547
74548   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74549   arg2 = jarg2 ? true : false;
74550   {
74551     try {
74552       (arg1)->SetActorAutoSnap(arg2);
74553     } catch (std::out_of_range& e) {
74554       {
74555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74556       };
74557     } catch (std::exception& e) {
74558       {
74559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74560       };
74561     } catch (...) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74564       };
74565     }
74566   }
74567 }
74568
74569
74570 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74572   bool arg2 ;
74573
74574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74575   arg2 = jarg2 ? true : false;
74576   {
74577     try {
74578       (arg1)->SetWrapMode(arg2);
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74586       };
74587     } catch (...) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74590       };
74591     }
74592   }
74593 }
74594
74595
74596 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74597   int jresult ;
74598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74599   int result;
74600
74601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74602   {
74603     try {
74604       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74605     } catch (std::out_of_range& e) {
74606       {
74607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74608       };
74609     } catch (std::exception& e) {
74610       {
74611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74612       };
74613     } catch (...) {
74614       {
74615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74616       };
74617     }
74618   }
74619   jresult = result;
74620   return jresult;
74621 }
74622
74623
74624 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74626   int arg2 ;
74627
74628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74629   arg2 = (int)jarg2;
74630   {
74631     try {
74632       (arg1)->SetScrollUpdateDistance(arg2);
74633     } catch (std::out_of_range& e) {
74634       {
74635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (std::exception& e) {
74638       {
74639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74644       };
74645     }
74646   }
74647 }
74648
74649
74650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_GetAxisAutoLock(void * jarg1) {
74651   unsigned int jresult ;
74652   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74653   bool result;
74654
74655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74656   {
74657     try {
74658       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74659     } catch (std::out_of_range& e) {
74660       {
74661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74662       };
74663     } catch (std::exception& e) {
74664       {
74665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74666       };
74667     } catch (...) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74670       };
74671     }
74672   }
74673   jresult = result;
74674   return jresult;
74675 }
74676
74677
74678 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74680   bool arg2 ;
74681
74682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74683   arg2 = jarg2 ? true : false;
74684   {
74685     try {
74686       (arg1)->SetAxisAutoLock(arg2);
74687     } catch (std::out_of_range& e) {
74688       {
74689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74690       };
74691     } catch (std::exception& e) {
74692       {
74693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74694       };
74695     } catch (...) {
74696       {
74697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74698       };
74699     }
74700   }
74701 }
74702
74703
74704 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74705   float jresult ;
74706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74707   float result;
74708
74709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74710   {
74711     try {
74712       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74713     } catch (std::out_of_range& e) {
74714       {
74715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (std::exception& e) {
74718       {
74719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74720       };
74721     } catch (...) {
74722       {
74723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74724       };
74725     }
74726   }
74727   jresult = result;
74728   return jresult;
74729 }
74730
74731
74732 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74734   float arg2 ;
74735
74736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74737   arg2 = (float)jarg2;
74738   {
74739     try {
74740       (arg1)->SetAxisAutoLockGradient(arg2);
74741     } catch (std::out_of_range& e) {
74742       {
74743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74744       };
74745     } catch (std::exception& e) {
74746       {
74747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74748       };
74749     } catch (...) {
74750       {
74751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74752       };
74753     }
74754   }
74755 }
74756
74757
74758 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetFrictionCoefficient(void * jarg1) {
74759   float jresult ;
74760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74761   float result;
74762
74763   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74764   {
74765     try {
74766       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74767     } catch (std::out_of_range& e) {
74768       {
74769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74770       };
74771     } catch (std::exception& e) {
74772       {
74773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74774       };
74775     } catch (...) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74778       };
74779     }
74780   }
74781   jresult = result;
74782   return jresult;
74783 }
74784
74785
74786 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74788   float arg2 ;
74789
74790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74791   arg2 = (float)jarg2;
74792   {
74793     try {
74794       (arg1)->SetFrictionCoefficient(arg2);
74795     } catch (std::out_of_range& e) {
74796       {
74797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74798       };
74799     } catch (std::exception& e) {
74800       {
74801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74802       };
74803     } catch (...) {
74804       {
74805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74806       };
74807     }
74808   }
74809 }
74810
74811
74812 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74813   float jresult ;
74814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74815   float result;
74816
74817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74818   {
74819     try {
74820       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74821     } catch (std::out_of_range& e) {
74822       {
74823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74824       };
74825     } catch (std::exception& e) {
74826       {
74827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74828       };
74829     } catch (...) {
74830       {
74831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74832       };
74833     }
74834   }
74835   jresult = result;
74836   return jresult;
74837 }
74838
74839
74840 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74842   float arg2 ;
74843
74844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74845   arg2 = (float)jarg2;
74846   {
74847     try {
74848       (arg1)->SetFlickSpeedCoefficient(arg2);
74849     } catch (std::out_of_range& e) {
74850       {
74851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74852       };
74853     } catch (std::exception& e) {
74854       {
74855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74856       };
74857     } catch (...) {
74858       {
74859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74860       };
74861     }
74862   }
74863 }
74864
74865
74866 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74867   void * jresult ;
74868   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74869   Dali::Vector2 result;
74870
74871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74872   {
74873     try {
74874       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74875     } catch (std::out_of_range& e) {
74876       {
74877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74878       };
74879     } catch (std::exception& e) {
74880       {
74881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74882       };
74883     } catch (...) {
74884       {
74885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74886       };
74887     }
74888   }
74889   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74890   return jresult;
74891 }
74892
74893
74894 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74896   Dali::Vector2 *arg2 = 0 ;
74897
74898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74899   arg2 = (Dali::Vector2 *)jarg2;
74900   if (!arg2) {
74901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74902     return ;
74903   }
74904   {
74905     try {
74906       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74907     } catch (std::out_of_range& e) {
74908       {
74909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74910       };
74911     } catch (std::exception& e) {
74912       {
74913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74914       };
74915     } catch (...) {
74916       {
74917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74918       };
74919     }
74920   }
74921 }
74922
74923
74924 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74925   float jresult ;
74926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74927   float result;
74928
74929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74930   {
74931     try {
74932       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74933     } catch (std::out_of_range& e) {
74934       {
74935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74936       };
74937     } catch (std::exception& e) {
74938       {
74939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74940       };
74941     } catch (...) {
74942       {
74943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74944       };
74945     }
74946   }
74947   jresult = result;
74948   return jresult;
74949 }
74950
74951
74952 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74954   float arg2 ;
74955
74956   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74957   arg2 = (float)jarg2;
74958   {
74959     try {
74960       (arg1)->SetMinimumSpeedForFlick(arg2);
74961     } catch (std::out_of_range& e) {
74962       {
74963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74964       };
74965     } catch (std::exception& e) {
74966       {
74967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (...) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74972       };
74973     }
74974   }
74975 }
74976
74977
74978 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74979   float jresult ;
74980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74981   float result;
74982
74983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74984   {
74985     try {
74986       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74987     } catch (std::out_of_range& e) {
74988       {
74989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74990       };
74991     } catch (std::exception& e) {
74992       {
74993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74994       };
74995     } catch (...) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74998       };
74999     }
75000   }
75001   jresult = result;
75002   return jresult;
75003 }
75004
75005
75006 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75008   float arg2 ;
75009
75010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75011   arg2 = (float)jarg2;
75012   {
75013     try {
75014       (arg1)->SetMaxFlickSpeed(arg2);
75015     } catch (std::out_of_range& e) {
75016       {
75017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75018       };
75019     } catch (std::exception& e) {
75020       {
75021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75022       };
75023     } catch (...) {
75024       {
75025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75026       };
75027     }
75028   }
75029 }
75030
75031
75032 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75033   void * jresult ;
75034   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75035   Dali::Vector2 result;
75036
75037   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75038   {
75039     try {
75040       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75041     } catch (std::out_of_range& e) {
75042       {
75043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75044       };
75045     } catch (std::exception& e) {
75046       {
75047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75048       };
75049     } catch (...) {
75050       {
75051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75052       };
75053     }
75054   }
75055   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75061   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75062   Dali::Vector2 arg2 ;
75063   Dali::Vector2 *argp2 ;
75064
75065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75066   argp2 = (Dali::Vector2 *)jarg2;
75067   if (!argp2) {
75068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75069     return ;
75070   }
75071   arg2 = *argp2;
75072   {
75073     try {
75074       (arg1)->SetWheelScrollDistanceStep(arg2);
75075     } catch (std::out_of_range& e) {
75076       {
75077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75078       };
75079     } catch (std::exception& e) {
75080       {
75081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75082       };
75083     } catch (...) {
75084       {
75085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75086       };
75087     }
75088   }
75089 }
75090
75091
75092 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75093   void * jresult ;
75094   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75095   Dali::Vector2 result;
75096
75097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75098   {
75099     try {
75100       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75101     } catch (std::out_of_range& e) {
75102       {
75103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75104       };
75105     } catch (std::exception& e) {
75106       {
75107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75108       };
75109     } catch (...) {
75110       {
75111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75112       };
75113     }
75114   }
75115   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75116   return jresult;
75117 }
75118
75119
75120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_GetCurrentPage(void * jarg1) {
75121   unsigned int jresult ;
75122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75123   unsigned int result;
75124
75125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75126   {
75127     try {
75128       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75129     } catch (std::out_of_range& e) {
75130       {
75131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75132       };
75133     } catch (std::exception& e) {
75134       {
75135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75136       };
75137     } catch (...) {
75138       {
75139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75140       };
75141     }
75142   }
75143   jresult = result;
75144   return jresult;
75145 }
75146
75147
75148 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75149   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75150   Dali::Vector2 *arg2 = 0 ;
75151
75152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75153   arg2 = (Dali::Vector2 *)jarg2;
75154   if (!arg2) {
75155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75156     return ;
75157   }
75158   {
75159     try {
75160       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75161     } catch (std::out_of_range& e) {
75162       {
75163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75164       };
75165     } catch (std::exception& e) {
75166       {
75167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75168       };
75169     } catch (...) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75172       };
75173     }
75174   }
75175 }
75176
75177
75178 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75180   Dali::Vector2 *arg2 = 0 ;
75181   float arg3 ;
75182
75183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75184   arg2 = (Dali::Vector2 *)jarg2;
75185   if (!arg2) {
75186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75187     return ;
75188   }
75189   arg3 = (float)jarg3;
75190   {
75191     try {
75192       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75200       };
75201     } catch (...) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75204       };
75205     }
75206   }
75207 }
75208
75209
75210 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75211   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75212   Dali::Vector2 *arg2 = 0 ;
75213   float arg3 ;
75214   Dali::AlphaFunction arg4 ;
75215   Dali::AlphaFunction *argp4 ;
75216
75217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75218   arg2 = (Dali::Vector2 *)jarg2;
75219   if (!arg2) {
75220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75221     return ;
75222   }
75223   arg3 = (float)jarg3;
75224   argp4 = (Dali::AlphaFunction *)jarg4;
75225   if (!argp4) {
75226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75227     return ;
75228   }
75229   arg4 = *argp4;
75230   {
75231     try {
75232       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75233     } catch (std::out_of_range& e) {
75234       {
75235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75236       };
75237     } catch (std::exception& e) {
75238       {
75239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75240       };
75241     } catch (...) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75244       };
75245     }
75246   }
75247 }
75248
75249
75250 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75251   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75252   Dali::Vector2 *arg2 = 0 ;
75253   float arg3 ;
75254   Dali::Toolkit::DirectionBias arg4 ;
75255   Dali::Toolkit::DirectionBias arg5 ;
75256
75257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75258   arg2 = (Dali::Vector2 *)jarg2;
75259   if (!arg2) {
75260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75261     return ;
75262   }
75263   arg3 = (float)jarg3;
75264   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75265   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75266   {
75267     try {
75268       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75269     } catch (std::out_of_range& e) {
75270       {
75271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75272       };
75273     } catch (std::exception& e) {
75274       {
75275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75276       };
75277     } catch (...) {
75278       {
75279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75280       };
75281     }
75282   }
75283 }
75284
75285
75286 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75288   Dali::Vector2 *arg2 = 0 ;
75289   float arg3 ;
75290   Dali::AlphaFunction arg4 ;
75291   Dali::Toolkit::DirectionBias arg5 ;
75292   Dali::Toolkit::DirectionBias arg6 ;
75293   Dali::AlphaFunction *argp4 ;
75294
75295   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75296   arg2 = (Dali::Vector2 *)jarg2;
75297   if (!arg2) {
75298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75299     return ;
75300   }
75301   arg3 = (float)jarg3;
75302   argp4 = (Dali::AlphaFunction *)jarg4;
75303   if (!argp4) {
75304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75305     return ;
75306   }
75307   arg4 = *argp4;
75308   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75309   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75310   {
75311     try {
75312       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75313     } catch (std::out_of_range& e) {
75314       {
75315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75316       };
75317     } catch (std::exception& e) {
75318       {
75319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75320       };
75321     } catch (...) {
75322       {
75323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75324       };
75325     }
75326   }
75327 }
75328
75329
75330 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75331   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75332   unsigned int arg2 ;
75333
75334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75335   arg2 = (unsigned int)jarg2;
75336   {
75337     try {
75338       (arg1)->ScrollTo(arg2);
75339     } catch (std::out_of_range& e) {
75340       {
75341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (std::exception& e) {
75344       {
75345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75346       };
75347     } catch (...) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75350       };
75351     }
75352   }
75353 }
75354
75355
75356 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75357   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75358   unsigned int arg2 ;
75359   float arg3 ;
75360
75361   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75362   arg2 = (unsigned int)jarg2;
75363   arg3 = (float)jarg3;
75364   {
75365     try {
75366       (arg1)->ScrollTo(arg2,arg3);
75367     } catch (std::out_of_range& e) {
75368       {
75369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75370       };
75371     } catch (std::exception& e) {
75372       {
75373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75374       };
75375     } catch (...) {
75376       {
75377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75378       };
75379     }
75380   }
75381 }
75382
75383
75384 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75385   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75386   unsigned int arg2 ;
75387   float arg3 ;
75388   Dali::Toolkit::DirectionBias arg4 ;
75389
75390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75391   arg2 = (unsigned int)jarg2;
75392   arg3 = (float)jarg3;
75393   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75394   {
75395     try {
75396       (arg1)->ScrollTo(arg2,arg3,arg4);
75397     } catch (std::out_of_range& e) {
75398       {
75399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75400       };
75401     } catch (std::exception& e) {
75402       {
75403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75404       };
75405     } catch (...) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75408       };
75409     }
75410   }
75411 }
75412
75413
75414 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75415   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75416   Dali::Actor *arg2 = 0 ;
75417
75418   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75419   arg2 = (Dali::Actor *)jarg2;
75420   if (!arg2) {
75421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75422     return ;
75423   }
75424   {
75425     try {
75426       (arg1)->ScrollTo(*arg2);
75427     } catch (std::out_of_range& e) {
75428       {
75429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75430       };
75431     } catch (std::exception& e) {
75432       {
75433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75434       };
75435     } catch (...) {
75436       {
75437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75438       };
75439     }
75440   }
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75446   Dali::Actor *arg2 = 0 ;
75447   float arg3 ;
75448
75449   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75450   arg2 = (Dali::Actor *)jarg2;
75451   if (!arg2) {
75452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75453     return ;
75454   }
75455   arg3 = (float)jarg3;
75456   {
75457     try {
75458       (arg1)->ScrollTo(*arg2,arg3);
75459     } catch (std::out_of_range& e) {
75460       {
75461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75462       };
75463     } catch (std::exception& e) {
75464       {
75465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75466       };
75467     } catch (...) {
75468       {
75469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75470       };
75471     }
75472   }
75473 }
75474
75475
75476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollView_ScrollToSnapPoint(void * jarg1) {
75477   unsigned int jresult ;
75478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75479   bool result;
75480
75481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75482   {
75483     try {
75484       result = (bool)(arg1)->ScrollToSnapPoint();
75485     } catch (std::out_of_range& e) {
75486       {
75487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (std::exception& e) {
75490       {
75491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75496       };
75497     }
75498   }
75499   jresult = result;
75500   return jresult;
75501 }
75502
75503
75504 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75506   Dali::Constraint arg2 ;
75507   Dali::Constraint *argp2 ;
75508
75509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75510   argp2 = (Dali::Constraint *)jarg2;
75511   if (!argp2) {
75512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75513     return ;
75514   }
75515   arg2 = *argp2;
75516   {
75517     try {
75518       (arg1)->ApplyConstraintToChildren(arg2);
75519     } catch (std::out_of_range& e) {
75520       {
75521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75522       };
75523     } catch (std::exception& e) {
75524       {
75525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75530       };
75531     }
75532   }
75533 }
75534
75535
75536 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75538
75539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75540   {
75541     try {
75542       (arg1)->RemoveConstraintsFromChildren();
75543     } catch (std::out_of_range& e) {
75544       {
75545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75546       };
75547     } catch (std::exception& e) {
75548       {
75549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75550       };
75551     } catch (...) {
75552       {
75553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75554       };
75555     }
75556   }
75557 }
75558
75559
75560 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75562   Dali::Toolkit::ScrollViewEffect arg2 ;
75563   Dali::Toolkit::ScrollViewEffect *argp2 ;
75564
75565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75566   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75567   if (!argp2) {
75568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75569     return ;
75570   }
75571   arg2 = *argp2;
75572   {
75573     try {
75574       (arg1)->ApplyEffect(arg2);
75575     } catch (std::out_of_range& e) {
75576       {
75577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75578       };
75579     } catch (std::exception& e) {
75580       {
75581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75582       };
75583     } catch (...) {
75584       {
75585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75586       };
75587     }
75588   }
75589 }
75590
75591
75592 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75594   Dali::Toolkit::ScrollViewEffect arg2 ;
75595   Dali::Toolkit::ScrollViewEffect *argp2 ;
75596
75597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75598   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75599   if (!argp2) {
75600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75601     return ;
75602   }
75603   arg2 = *argp2;
75604   {
75605     try {
75606       (arg1)->RemoveEffect(arg2);
75607     } catch (std::out_of_range& e) {
75608       {
75609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75610       };
75611     } catch (std::exception& e) {
75612       {
75613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75614       };
75615     } catch (...) {
75616       {
75617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75618       };
75619     }
75620   }
75621 }
75622
75623
75624 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveAllEffects(void * jarg1) {
75625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75626
75627   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75628   {
75629     try {
75630       (arg1)->RemoveAllEffects();
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75642       };
75643     }
75644   }
75645 }
75646
75647
75648 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_BindActor(void * jarg1, void * jarg2) {
75649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75650   Dali::Actor arg2 ;
75651   Dali::Actor *argp2 ;
75652
75653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75654   argp2 = (Dali::Actor *)jarg2;
75655   if (!argp2) {
75656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75657     return ;
75658   }
75659   arg2 = *argp2;
75660   {
75661     try {
75662       (arg1)->BindActor(arg2);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75674       };
75675     }
75676   }
75677 }
75678
75679
75680 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75681   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75682   Dali::Actor arg2 ;
75683   Dali::Actor *argp2 ;
75684
75685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75686   argp2 = (Dali::Actor *)jarg2;
75687   if (!argp2) {
75688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75689     return ;
75690   }
75691   arg2 = *argp2;
75692   {
75693     try {
75694       (arg1)->UnbindActor(arg2);
75695     } catch (std::out_of_range& e) {
75696       {
75697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75698       };
75699     } catch (std::exception& e) {
75700       {
75701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75702       };
75703     } catch (...) {
75704       {
75705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75706       };
75707     }
75708   }
75709 }
75710
75711
75712 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75714   Dali::Radian arg2 ;
75715   Dali::Radian arg3 ;
75716   Dali::Radian *argp2 ;
75717   Dali::Radian *argp3 ;
75718
75719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75720   argp2 = (Dali::Radian *)jarg2;
75721   if (!argp2) {
75722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75723     return ;
75724   }
75725   arg2 = *argp2;
75726   argp3 = (Dali::Radian *)jarg3;
75727   if (!argp3) {
75728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75729     return ;
75730   }
75731   arg3 = *argp3;
75732   {
75733     try {
75734       (arg1)->SetScrollingDirection(arg2,arg3);
75735     } catch (std::out_of_range& e) {
75736       {
75737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75738       };
75739     } catch (std::exception& e) {
75740       {
75741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75742       };
75743     } catch (...) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75746       };
75747     }
75748   }
75749 }
75750
75751
75752 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75754   Dali::Radian arg2 ;
75755   Dali::Radian *argp2 ;
75756
75757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75758   argp2 = (Dali::Radian *)jarg2;
75759   if (!argp2) {
75760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75761     return ;
75762   }
75763   arg2 = *argp2;
75764   {
75765     try {
75766       (arg1)->SetScrollingDirection(arg2);
75767     } catch (std::out_of_range& e) {
75768       {
75769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75770       };
75771     } catch (std::exception& e) {
75772       {
75773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75774       };
75775     } catch (...) {
75776       {
75777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75778       };
75779     }
75780   }
75781 }
75782
75783
75784 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75786   Dali::Radian arg2 ;
75787   Dali::Radian *argp2 ;
75788
75789   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75790   argp2 = (Dali::Radian *)jarg2;
75791   if (!argp2) {
75792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75793     return ;
75794   }
75795   arg2 = *argp2;
75796   {
75797     try {
75798       (arg1)->RemoveScrollingDirection(arg2);
75799     } catch (std::out_of_range& e) {
75800       {
75801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75802       };
75803     } catch (std::exception& e) {
75804       {
75805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75806       };
75807     } catch (...) {
75808       {
75809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75810       };
75811     }
75812   }
75813 }
75814
75815
75816 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ScrollView_SnapStartedSignal(void * jarg1) {
75817   void * jresult ;
75818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75819   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75820
75821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75822   {
75823     try {
75824       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75825     } catch (std::out_of_range& e) {
75826       {
75827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75828       };
75829     } catch (std::exception& e) {
75830       {
75831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75832       };
75833     } catch (...) {
75834       {
75835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75836       };
75837     }
75838   }
75839   jresult = (void *)result;
75840   return jresult;
75841 }
75842
75843
75844 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_ROWS_get() {
75845   int jresult ;
75846   int result;
75847
75848   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75849   jresult = (int)result;
75850   return jresult;
75851 }
75852
75853
75854 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_COLUMNS_get() {
75855   int jresult ;
75856   int result;
75857
75858   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75859   jresult = (int)result;
75860   return jresult;
75861 }
75862
75863
75864 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_CELL_PADDING_get() {
75865   int jresult ;
75866   int result;
75867
75868   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75869   jresult = (int)result;
75870   return jresult;
75871 }
75872
75873
75874 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_LAYOUT_ROWS_get() {
75875   int jresult ;
75876   int result;
75877
75878   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75879   jresult = (int)result;
75880   return jresult;
75881 }
75882
75883
75884 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_Property_LAYOUT_COLUMNS_get() {
75885   int jresult ;
75886   int result;
75887
75888   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75889   jresult = (int)result;
75890   return jresult;
75891 }
75892
75893
75894 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_Property() {
75895   void * jresult ;
75896   Dali::Toolkit::TableView::Property *result = 0 ;
75897
75898   {
75899     try {
75900       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75901     } catch (std::out_of_range& e) {
75902       {
75903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75904       };
75905     } catch (std::exception& e) {
75906       {
75907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75908       };
75909     } catch (...) {
75910       {
75911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75912       };
75913     }
75914   }
75915   jresult = (void *)result;
75916   return jresult;
75917 }
75918
75919
75920 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_Property(void * jarg1) {
75921   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75922
75923   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75924   {
75925     try {
75926       delete arg1;
75927     } catch (std::out_of_range& e) {
75928       {
75929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75930       };
75931     } catch (std::exception& e) {
75932       {
75933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75934       };
75935     } catch (...) {
75936       {
75937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75938       };
75939     }
75940   }
75941 }
75942
75943
75944 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_INDEX_get() {
75945   int jresult ;
75946   int result;
75947
75948   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75949   jresult = (int)result;
75950   return jresult;
75951 }
75952
75953
75954 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_ROW_SPAN_get() {
75955   int jresult ;
75956   int result;
75957
75958   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75959   jresult = (int)result;
75960   return jresult;
75961 }
75962
75963
75964 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_COLUMN_SPAN_get() {
75965   int jresult ;
75966   int result;
75967
75968   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75969   jresult = (int)result;
75970   return jresult;
75971 }
75972
75973
75974 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75975   int jresult ;
75976   int result;
75977
75978   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75979   jresult = (int)result;
75980   return jresult;
75981 }
75982
75983
75984 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75985   int jresult ;
75986   int result;
75987
75988   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75989   jresult = (int)result;
75990   return jresult;
75991 }
75992
75993
75994 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_ChildProperty() {
75995   void * jresult ;
75996   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75997
75998   {
75999     try {
76000       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76001     } catch (std::out_of_range& e) {
76002       {
76003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76004       };
76005     } catch (std::exception& e) {
76006       {
76007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76008       };
76009     } catch (...) {
76010       {
76011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76012       };
76013     }
76014   }
76015   jresult = (void *)result;
76016   return jresult;
76017 }
76018
76019
76020 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_ChildProperty(void * jarg1) {
76021   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76022
76023   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76024   {
76025     try {
76026       delete arg1;
76027     } catch (std::out_of_range& e) {
76028       {
76029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76030       };
76031     } catch (std::exception& e) {
76032       {
76033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76034       };
76035     } catch (...) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76038       };
76039     }
76040   }
76041 }
76042
76043
76044 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76045   void * jresult ;
76046   unsigned int arg1 ;
76047   unsigned int arg2 ;
76048   unsigned int arg3 ;
76049   unsigned int arg4 ;
76050   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76051
76052   arg1 = (unsigned int)jarg1;
76053   arg2 = (unsigned int)jarg2;
76054   arg3 = (unsigned int)jarg3;
76055   arg4 = (unsigned int)jarg4;
76056   {
76057     try {
76058       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76059     } catch (std::out_of_range& e) {
76060       {
76061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76062       };
76063     } catch (std::exception& e) {
76064       {
76065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76066       };
76067     } catch (...) {
76068       {
76069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76070       };
76071     }
76072   }
76073   jresult = (void *)result;
76074   return jresult;
76075 }
76076
76077
76078 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76079   void * jresult ;
76080   unsigned int arg1 ;
76081   unsigned int arg2 ;
76082   unsigned int arg3 ;
76083   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76084
76085   arg1 = (unsigned int)jarg1;
76086   arg2 = (unsigned int)jarg2;
76087   arg3 = (unsigned int)jarg3;
76088   {
76089     try {
76090       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76091     } catch (std::out_of_range& e) {
76092       {
76093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76094       };
76095     } catch (std::exception& e) {
76096       {
76097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76098       };
76099     } catch (...) {
76100       {
76101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76102       };
76103     }
76104   }
76105   jresult = (void *)result;
76106   return jresult;
76107 }
76108
76109
76110 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76111   void * jresult ;
76112   unsigned int arg1 ;
76113   unsigned int arg2 ;
76114   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76115
76116   arg1 = (unsigned int)jarg1;
76117   arg2 = (unsigned int)jarg2;
76118   {
76119     try {
76120       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76121     } catch (std::out_of_range& e) {
76122       {
76123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76124       };
76125     } catch (std::exception& e) {
76126       {
76127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76128       };
76129     } catch (...) {
76130       {
76131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76132       };
76133     }
76134   }
76135   jresult = (void *)result;
76136   return jresult;
76137 }
76138
76139
76140 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76141   void * jresult ;
76142   unsigned int arg1 ;
76143   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76144
76145   arg1 = (unsigned int)jarg1;
76146   {
76147     try {
76148       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76156       };
76157     } catch (...) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76160       };
76161     }
76162   }
76163   jresult = (void *)result;
76164   return jresult;
76165 }
76166
76167
76168 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView_CellPosition__SWIG_4() {
76169   void * jresult ;
76170   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76171
76172   {
76173     try {
76174       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76175     } catch (std::out_of_range& e) {
76176       {
76177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76178       };
76179     } catch (std::exception& e) {
76180       {
76181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76182       };
76183     } catch (...) {
76184       {
76185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76186       };
76187     }
76188   }
76189   jresult = (void *)result;
76190   return jresult;
76191 }
76192
76193
76194 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76195   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76196   unsigned int arg2 ;
76197
76198   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76199   arg2 = (unsigned int)jarg2;
76200   if (arg1) (arg1)->rowIndex = arg2;
76201 }
76202
76203
76204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowIndex_get(void * jarg1) {
76205   unsigned int jresult ;
76206   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76207   unsigned int result;
76208
76209   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76210   result = (unsigned int) ((arg1)->rowIndex);
76211   jresult = result;
76212   return jresult;
76213 }
76214
76215
76216 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76217   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76218   unsigned int arg2 ;
76219
76220   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76221   arg2 = (unsigned int)jarg2;
76222   if (arg1) (arg1)->columnIndex = arg2;
76223 }
76224
76225
76226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnIndex_get(void * jarg1) {
76227   unsigned int jresult ;
76228   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76229   unsigned int result;
76230
76231   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76232   result = (unsigned int) ((arg1)->columnIndex);
76233   jresult = result;
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76239   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76240   unsigned int arg2 ;
76241
76242   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76243   arg2 = (unsigned int)jarg2;
76244   if (arg1) (arg1)->rowSpan = arg2;
76245 }
76246
76247
76248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_rowSpan_get(void * jarg1) {
76249   unsigned int jresult ;
76250   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76251   unsigned int result;
76252
76253   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76254   result = (unsigned int) ((arg1)->rowSpan);
76255   jresult = result;
76256   return jresult;
76257 }
76258
76259
76260 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76261   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76262   unsigned int arg2 ;
76263
76264   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76265   arg2 = (unsigned int)jarg2;
76266   if (arg1) (arg1)->columnSpan = arg2;
76267 }
76268
76269
76270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_CellPosition_columnSpan_get(void * jarg1) {
76271   unsigned int jresult ;
76272   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76273   unsigned int result;
76274
76275   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76276   result = (unsigned int) ((arg1)->columnSpan);
76277   jresult = result;
76278   return jresult;
76279 }
76280
76281
76282 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView_CellPosition(void * jarg1) {
76283   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76284
76285   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76286   {
76287     try {
76288       delete arg1;
76289     } catch (std::out_of_range& e) {
76290       {
76291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76292       };
76293     } catch (std::exception& e) {
76294       {
76295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76296       };
76297     } catch (...) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76300       };
76301     }
76302   }
76303 }
76304
76305
76306 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView__SWIG_0() {
76307   void * jresult ;
76308   Dali::Toolkit::TableView *result = 0 ;
76309
76310   {
76311     try {
76312       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76313     } catch (std::out_of_range& e) {
76314       {
76315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76316       };
76317     } catch (std::exception& e) {
76318       {
76319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76320       };
76321     } catch (...) {
76322       {
76323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76324       };
76325     }
76326   }
76327   jresult = (void *)result;
76328   return jresult;
76329 }
76330
76331
76332 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TableView__SWIG_1(void * jarg1) {
76333   void * jresult ;
76334   Dali::Toolkit::TableView *arg1 = 0 ;
76335   Dali::Toolkit::TableView *result = 0 ;
76336
76337   arg1 = (Dali::Toolkit::TableView *)jarg1;
76338   if (!arg1) {
76339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76340     return 0;
76341   }
76342   {
76343     try {
76344       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76345     } catch (std::out_of_range& e) {
76346       {
76347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76348       };
76349     } catch (std::exception& e) {
76350       {
76351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76352       };
76353     } catch (...) {
76354       {
76355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76356       };
76357     }
76358   }
76359   jresult = (void *)result;
76360   return jresult;
76361 }
76362
76363
76364 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_Assign(void * jarg1, void * jarg2) {
76365   void * jresult ;
76366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76367   Dali::Toolkit::TableView *arg2 = 0 ;
76368   Dali::Toolkit::TableView *result = 0 ;
76369
76370   arg1 = (Dali::Toolkit::TableView *)jarg1;
76371   arg2 = (Dali::Toolkit::TableView *)jarg2;
76372   if (!arg2) {
76373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76374     return 0;
76375   }
76376   {
76377     try {
76378       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76379     } catch (std::out_of_range& e) {
76380       {
76381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76382       };
76383     } catch (std::exception& e) {
76384       {
76385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (...) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76390       };
76391     }
76392   }
76393   jresult = (void *)result;
76394   return jresult;
76395 }
76396
76397
76398 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TableView(void * jarg1) {
76399   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76400
76401   arg1 = (Dali::Toolkit::TableView *)jarg1;
76402   {
76403     try {
76404       delete arg1;
76405     } catch (std::out_of_range& e) {
76406       {
76407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76408       };
76409     } catch (std::exception& e) {
76410       {
76411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76412       };
76413     } catch (...) {
76414       {
76415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76416       };
76417     }
76418   }
76419 }
76420
76421
76422 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76423   void * jresult ;
76424   unsigned int arg1 ;
76425   unsigned int arg2 ;
76426   Dali::Toolkit::TableView result;
76427
76428   arg1 = (unsigned int)jarg1;
76429   arg2 = (unsigned int)jarg2;
76430   {
76431     try {
76432       result = Dali::Toolkit::TableView::New(arg1,arg2);
76433     } catch (std::out_of_range& e) {
76434       {
76435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76436       };
76437     } catch (std::exception& e) {
76438       {
76439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76440       };
76441     } catch (...) {
76442       {
76443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76444       };
76445     }
76446   }
76447   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76448   return jresult;
76449 }
76450
76451
76452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_DownCast(void * jarg1) {
76453   void * jresult ;
76454   Dali::BaseHandle arg1 ;
76455   Dali::BaseHandle *argp1 ;
76456   Dali::Toolkit::TableView result;
76457
76458   argp1 = (Dali::BaseHandle *)jarg1;
76459   if (!argp1) {
76460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76461     return 0;
76462   }
76463   arg1 = *argp1;
76464   {
76465     try {
76466       result = Dali::Toolkit::TableView::DownCast(arg1);
76467     } catch (std::out_of_range& e) {
76468       {
76469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76470       };
76471     } catch (std::exception& e) {
76472       {
76473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76474       };
76475     } catch (...) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76478       };
76479     }
76480   }
76481   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76482   return jresult;
76483 }
76484
76485
76486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76487   unsigned int jresult ;
76488   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76489   Dali::Actor arg2 ;
76490   Dali::Toolkit::TableView::CellPosition arg3 ;
76491   Dali::Actor *argp2 ;
76492   Dali::Toolkit::TableView::CellPosition *argp3 ;
76493   bool result;
76494
76495   arg1 = (Dali::Toolkit::TableView *)jarg1;
76496   argp2 = (Dali::Actor *)jarg2;
76497   if (!argp2) {
76498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76499     return 0;
76500   }
76501   arg2 = *argp2;
76502   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76503   if (!argp3) {
76504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76505     return 0;
76506   }
76507   arg3 = *argp3;
76508   {
76509     try {
76510       result = (bool)(arg1)->AddChild(arg2,arg3);
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76518       };
76519     } catch (...) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76522       };
76523     }
76524   }
76525   jresult = result;
76526   return jresult;
76527 }
76528
76529
76530 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_GetChildAt(void * jarg1, void * jarg2) {
76531   void * jresult ;
76532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76533   Dali::Toolkit::TableView::CellPosition arg2 ;
76534   Dali::Toolkit::TableView::CellPosition *argp2 ;
76535   Dali::Actor result;
76536
76537   arg1 = (Dali::Toolkit::TableView *)jarg1;
76538   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76539   if (!argp2) {
76540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76541     return 0;
76542   }
76543   arg2 = *argp2;
76544   {
76545     try {
76546       result = (arg1)->GetChildAt(arg2);
76547     } catch (std::out_of_range& e) {
76548       {
76549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (std::exception& e) {
76552       {
76553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76558       };
76559     }
76560   }
76561   jresult = new Dali::Actor((const Dali::Actor &)result);
76562   return jresult;
76563 }
76564
76565
76566 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76567   void * jresult ;
76568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76569   Dali::Toolkit::TableView::CellPosition arg2 ;
76570   Dali::Toolkit::TableView::CellPosition *argp2 ;
76571   Dali::Actor result;
76572
76573   arg1 = (Dali::Toolkit::TableView *)jarg1;
76574   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76575   if (!argp2) {
76576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76577     return 0;
76578   }
76579   arg2 = *argp2;
76580   {
76581     try {
76582       result = (arg1)->RemoveChildAt(arg2);
76583     } catch (std::out_of_range& e) {
76584       {
76585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76586       };
76587     } catch (std::exception& e) {
76588       {
76589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76590       };
76591     } catch (...) {
76592       {
76593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76594       };
76595     }
76596   }
76597   jresult = new Dali::Actor((const Dali::Actor &)result);
76598   return jresult;
76599 }
76600
76601
76602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76603   unsigned int jresult ;
76604   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76605   Dali::Actor arg2 ;
76606   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76607   Dali::Actor *argp2 ;
76608   bool result;
76609
76610   arg1 = (Dali::Toolkit::TableView *)jarg1;
76611   argp2 = (Dali::Actor *)jarg2;
76612   if (!argp2) {
76613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76614     return 0;
76615   }
76616   arg2 = *argp2;
76617   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76618   if (!arg3) {
76619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76620     return 0;
76621   }
76622   {
76623     try {
76624       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76625     } catch (std::out_of_range& e) {
76626       {
76627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76628       };
76629     } catch (std::exception& e) {
76630       {
76631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76632       };
76633     } catch (...) {
76634       {
76635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76636       };
76637     }
76638   }
76639   jresult = result;
76640   return jresult;
76641 }
76642
76643
76644 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76646   unsigned int arg2 ;
76647
76648   arg1 = (Dali::Toolkit::TableView *)jarg1;
76649   arg2 = (unsigned int)jarg2;
76650   {
76651     try {
76652       (arg1)->InsertRow(arg2);
76653     } catch (std::out_of_range& e) {
76654       {
76655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76656       };
76657     } catch (std::exception& e) {
76658       {
76659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76660       };
76661     } catch (...) {
76662       {
76663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76664       };
76665     }
76666   }
76667 }
76668
76669
76670 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76671   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76672   unsigned int arg2 ;
76673
76674   arg1 = (Dali::Toolkit::TableView *)jarg1;
76675   arg2 = (unsigned int)jarg2;
76676   {
76677     try {
76678       (arg1)->DeleteRow(arg2);
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76686       };
76687     } catch (...) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76690       };
76691     }
76692   }
76693 }
76694
76695
76696 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76698   unsigned int arg2 ;
76699   std::vector< Dali::Actor > *arg3 = 0 ;
76700
76701   arg1 = (Dali::Toolkit::TableView *)jarg1;
76702   arg2 = (unsigned int)jarg2;
76703   arg3 = (std::vector< Dali::Actor > *)jarg3;
76704   if (!arg3) {
76705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76706     return ;
76707   }
76708   {
76709     try {
76710       (arg1)->DeleteRow(arg2,*arg3);
76711     } catch (std::out_of_range& e) {
76712       {
76713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76714       };
76715     } catch (std::exception& e) {
76716       {
76717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76718       };
76719     } catch (...) {
76720       {
76721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76722       };
76723     }
76724   }
76725 }
76726
76727
76728 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76729   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76730   unsigned int arg2 ;
76731
76732   arg1 = (Dali::Toolkit::TableView *)jarg1;
76733   arg2 = (unsigned int)jarg2;
76734   {
76735     try {
76736       (arg1)->InsertColumn(arg2);
76737     } catch (std::out_of_range& e) {
76738       {
76739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76740       };
76741     } catch (std::exception& e) {
76742       {
76743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (...) {
76746       {
76747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76748       };
76749     }
76750   }
76751 }
76752
76753
76754 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76755   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76756   unsigned int arg2 ;
76757
76758   arg1 = (Dali::Toolkit::TableView *)jarg1;
76759   arg2 = (unsigned int)jarg2;
76760   {
76761     try {
76762       (arg1)->DeleteColumn(arg2);
76763     } catch (std::out_of_range& e) {
76764       {
76765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76766       };
76767     } catch (std::exception& e) {
76768       {
76769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76770       };
76771     } catch (...) {
76772       {
76773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76774       };
76775     }
76776   }
76777 }
76778
76779
76780 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76781   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76782   unsigned int arg2 ;
76783   std::vector< Dali::Actor > *arg3 = 0 ;
76784
76785   arg1 = (Dali::Toolkit::TableView *)jarg1;
76786   arg2 = (unsigned int)jarg2;
76787   arg3 = (std::vector< Dali::Actor > *)jarg3;
76788   if (!arg3) {
76789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76790     return ;
76791   }
76792   {
76793     try {
76794       (arg1)->DeleteColumn(arg2,*arg3);
76795     } catch (std::out_of_range& e) {
76796       {
76797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76798       };
76799     } catch (std::exception& e) {
76800       {
76801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76802       };
76803     } catch (...) {
76804       {
76805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76806       };
76807     }
76808   }
76809 }
76810
76811
76812 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76813   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76814   unsigned int arg2 ;
76815   unsigned int arg3 ;
76816
76817   arg1 = (Dali::Toolkit::TableView *)jarg1;
76818   arg2 = (unsigned int)jarg2;
76819   arg3 = (unsigned int)jarg3;
76820   {
76821     try {
76822       (arg1)->Resize(arg2,arg3);
76823     } catch (std::out_of_range& e) {
76824       {
76825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76826       };
76827     } catch (std::exception& e) {
76828       {
76829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (...) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76834       };
76835     }
76836   }
76837 }
76838
76839
76840 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76841   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76842   unsigned int arg2 ;
76843   unsigned int arg3 ;
76844   std::vector< Dali::Actor > *arg4 = 0 ;
76845
76846   arg1 = (Dali::Toolkit::TableView *)jarg1;
76847   arg2 = (unsigned int)jarg2;
76848   arg3 = (unsigned int)jarg3;
76849   arg4 = (std::vector< Dali::Actor > *)jarg4;
76850   if (!arg4) {
76851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76852     return ;
76853   }
76854   {
76855     try {
76856       (arg1)->Resize(arg2,arg3,*arg4);
76857     } catch (std::out_of_range& e) {
76858       {
76859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76860       };
76861     } catch (std::exception& e) {
76862       {
76863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76864       };
76865     } catch (...) {
76866       {
76867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76868       };
76869     }
76870   }
76871 }
76872
76873
76874 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76875   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76876   Dali::Size arg2 ;
76877   Dali::Size *argp2 ;
76878
76879   arg1 = (Dali::Toolkit::TableView *)jarg1;
76880   argp2 = (Dali::Size *)jarg2;
76881   if (!argp2) {
76882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76883     return ;
76884   }
76885   arg2 = *argp2;
76886   {
76887     try {
76888       (arg1)->SetCellPadding(arg2);
76889     } catch (std::out_of_range& e) {
76890       {
76891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76892       };
76893     } catch (std::exception& e) {
76894       {
76895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76896       };
76897     } catch (...) {
76898       {
76899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76900       };
76901     }
76902   }
76903 }
76904
76905
76906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TableView_GetCellPadding(void * jarg1) {
76907   void * jresult ;
76908   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76909   Dali::Size result;
76910
76911   arg1 = (Dali::Toolkit::TableView *)jarg1;
76912   {
76913     try {
76914       result = (arg1)->GetCellPadding();
76915     } catch (std::out_of_range& e) {
76916       {
76917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76918       };
76919     } catch (std::exception& e) {
76920       {
76921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76922       };
76923     } catch (...) {
76924       {
76925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76926       };
76927     }
76928   }
76929   jresult = new Dali::Size((const Dali::Size &)result);
76930   return jresult;
76931 }
76932
76933
76934 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76935   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76936   unsigned int arg2 ;
76937
76938   arg1 = (Dali::Toolkit::TableView *)jarg1;
76939   arg2 = (unsigned int)jarg2;
76940   {
76941     try {
76942       (arg1)->SetFitHeight(arg2);
76943     } catch (std::out_of_range& e) {
76944       {
76945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76946       };
76947     } catch (std::exception& e) {
76948       {
76949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76950       };
76951     } catch (...) {
76952       {
76953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76954       };
76955     }
76956   }
76957 }
76958
76959
76960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76961   unsigned int jresult ;
76962   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76963   unsigned int arg2 ;
76964   bool result;
76965
76966   arg1 = (Dali::Toolkit::TableView *)jarg1;
76967   arg2 = (unsigned int)jarg2;
76968   {
76969     try {
76970       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76971     } catch (std::out_of_range& e) {
76972       {
76973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76974       };
76975     } catch (std::exception& e) {
76976       {
76977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76978       };
76979     } catch (...) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76982       };
76983     }
76984   }
76985   jresult = result;
76986   return jresult;
76987 }
76988
76989
76990 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76991   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76992   unsigned int arg2 ;
76993
76994   arg1 = (Dali::Toolkit::TableView *)jarg1;
76995   arg2 = (unsigned int)jarg2;
76996   {
76997     try {
76998       (arg1)->SetFitWidth(arg2);
76999     } catch (std::out_of_range& e) {
77000       {
77001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77002       };
77003     } catch (std::exception& e) {
77004       {
77005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77006       };
77007     } catch (...) {
77008       {
77009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77010       };
77011     }
77012   }
77013 }
77014
77015
77016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77017   unsigned int jresult ;
77018   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77019   unsigned int arg2 ;
77020   bool result;
77021
77022   arg1 = (Dali::Toolkit::TableView *)jarg1;
77023   arg2 = (unsigned int)jarg2;
77024   {
77025     try {
77026       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77027     } catch (std::out_of_range& e) {
77028       {
77029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77030       };
77031     } catch (std::exception& e) {
77032       {
77033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77034       };
77035     } catch (...) {
77036       {
77037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77038       };
77039     }
77040   }
77041   jresult = result;
77042   return jresult;
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77048   unsigned int arg2 ;
77049   float arg3 ;
77050
77051   arg1 = (Dali::Toolkit::TableView *)jarg1;
77052   arg2 = (unsigned int)jarg2;
77053   arg3 = (float)jarg3;
77054   {
77055     try {
77056       (arg1)->SetFixedHeight(arg2,arg3);
77057     } catch (std::out_of_range& e) {
77058       {
77059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (std::exception& e) {
77062       {
77063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77068       };
77069     }
77070   }
77071 }
77072
77073
77074 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77075   float jresult ;
77076   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77077   unsigned int arg2 ;
77078   float result;
77079
77080   arg1 = (Dali::Toolkit::TableView *)jarg1;
77081   arg2 = (unsigned int)jarg2;
77082   {
77083     try {
77084       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77085     } catch (std::out_of_range& e) {
77086       {
77087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77088       };
77089     } catch (std::exception& e) {
77090       {
77091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77092       };
77093     } catch (...) {
77094       {
77095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77096       };
77097     }
77098   }
77099   jresult = result;
77100   return jresult;
77101 }
77102
77103
77104 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77105   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77106   unsigned int arg2 ;
77107   float arg3 ;
77108
77109   arg1 = (Dali::Toolkit::TableView *)jarg1;
77110   arg2 = (unsigned int)jarg2;
77111   arg3 = (float)jarg3;
77112   {
77113     try {
77114       (arg1)->SetRelativeHeight(arg2,arg3);
77115     } catch (std::out_of_range& e) {
77116       {
77117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77118       };
77119     } catch (std::exception& e) {
77120       {
77121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77122       };
77123     } catch (...) {
77124       {
77125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77126       };
77127     }
77128   }
77129 }
77130
77131
77132 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77133   float jresult ;
77134   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77135   unsigned int arg2 ;
77136   float result;
77137
77138   arg1 = (Dali::Toolkit::TableView *)jarg1;
77139   arg2 = (unsigned int)jarg2;
77140   {
77141     try {
77142       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77143     } catch (std::out_of_range& e) {
77144       {
77145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (std::exception& e) {
77148       {
77149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77150       };
77151     } catch (...) {
77152       {
77153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77154       };
77155     }
77156   }
77157   jresult = result;
77158   return jresult;
77159 }
77160
77161
77162 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77163   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77164   unsigned int arg2 ;
77165   float arg3 ;
77166
77167   arg1 = (Dali::Toolkit::TableView *)jarg1;
77168   arg2 = (unsigned int)jarg2;
77169   arg3 = (float)jarg3;
77170   {
77171     try {
77172       (arg1)->SetFixedWidth(arg2,arg3);
77173     } catch (std::out_of_range& e) {
77174       {
77175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77176       };
77177     } catch (std::exception& e) {
77178       {
77179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77180       };
77181     } catch (...) {
77182       {
77183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77184       };
77185     }
77186   }
77187 }
77188
77189
77190 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77191   float jresult ;
77192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77193   unsigned int arg2 ;
77194   float result;
77195
77196   arg1 = (Dali::Toolkit::TableView *)jarg1;
77197   arg2 = (unsigned int)jarg2;
77198   {
77199     try {
77200       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77201     } catch (std::out_of_range& e) {
77202       {
77203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77204       };
77205     } catch (std::exception& e) {
77206       {
77207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77208       };
77209     } catch (...) {
77210       {
77211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77212       };
77213     }
77214   }
77215   jresult = result;
77216   return jresult;
77217 }
77218
77219
77220 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77221   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77222   unsigned int arg2 ;
77223   float arg3 ;
77224
77225   arg1 = (Dali::Toolkit::TableView *)jarg1;
77226   arg2 = (unsigned int)jarg2;
77227   arg3 = (float)jarg3;
77228   {
77229     try {
77230       (arg1)->SetRelativeWidth(arg2,arg3);
77231     } catch (std::out_of_range& e) {
77232       {
77233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77234       };
77235     } catch (std::exception& e) {
77236       {
77237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77238       };
77239     } catch (...) {
77240       {
77241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77242       };
77243     }
77244   }
77245 }
77246
77247
77248 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77249   float jresult ;
77250   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77251   unsigned int arg2 ;
77252   float result;
77253
77254   arg1 = (Dali::Toolkit::TableView *)jarg1;
77255   arg2 = (unsigned int)jarg2;
77256   {
77257     try {
77258       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77259     } catch (std::out_of_range& e) {
77260       {
77261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77262       };
77263     } catch (std::exception& e) {
77264       {
77265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77266       };
77267     } catch (...) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77270       };
77271     }
77272   }
77273   jresult = result;
77274   return jresult;
77275 }
77276
77277
77278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_GetRows(void * jarg1) {
77279   unsigned int jresult ;
77280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77281   unsigned int result;
77282
77283   arg1 = (Dali::Toolkit::TableView *)jarg1;
77284   {
77285     try {
77286       result = (unsigned int)(arg1)->GetRows();
77287     } catch (std::out_of_range& e) {
77288       {
77289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77290       };
77291     } catch (std::exception& e) {
77292       {
77293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77294       };
77295     } catch (...) {
77296       {
77297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77298       };
77299     }
77300   }
77301   jresult = result;
77302   return jresult;
77303 }
77304
77305
77306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TableView_GetColumns(void * jarg1) {
77307   unsigned int jresult ;
77308   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77309   unsigned int result;
77310
77311   arg1 = (Dali::Toolkit::TableView *)jarg1;
77312   {
77313     try {
77314       result = (unsigned int)(arg1)->GetColumns();
77315     } catch (std::out_of_range& e) {
77316       {
77317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77318       };
77319     } catch (std::exception& e) {
77320       {
77321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77322       };
77323     } catch (...) {
77324       {
77325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77326       };
77327     }
77328   }
77329   jresult = result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77336   Dali::Toolkit::TableView::CellPosition arg2 ;
77337   Dali::HorizontalAlignment::Type arg3 ;
77338   Dali::VerticalAlignment::Type arg4 ;
77339   Dali::Toolkit::TableView::CellPosition *argp2 ;
77340
77341   arg1 = (Dali::Toolkit::TableView *)jarg1;
77342   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77343   if (!argp2) {
77344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77345     return ;
77346   }
77347   arg2 = *argp2;
77348   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77349   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77350   {
77351     try {
77352       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77353     } catch (std::out_of_range& e) {
77354       {
77355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77356       };
77357     } catch (std::exception& e) {
77358       {
77359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77360       };
77361     } catch (...) {
77362       {
77363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77364       };
77365     }
77366   }
77367 }
77368
77369
77370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_DEFAULT_RENDERING_BACKEND_get() {
77371   unsigned int jresult ;
77372   unsigned int result;
77373
77374   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77375   jresult = result;
77376   return jresult;
77377 }
77378
77379
77380 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_RENDERING_BACKEND_get() {
77381   int jresult ;
77382   int result;
77383
77384   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77385   jresult = (int)result;
77386   return jresult;
77387 }
77388
77389
77390 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_TEXT_get() {
77391   int jresult ;
77392   int result;
77393
77394   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77395   jresult = (int)result;
77396   return jresult;
77397 }
77398
77399
77400 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_TEXT_COLOR_get() {
77401   int jresult ;
77402   int result;
77403
77404   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77405   jresult = (int)result;
77406   return jresult;
77407 }
77408
77409
77410 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_FONT_FAMILY_get() {
77411   int jresult ;
77412   int result;
77413
77414   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77415   jresult = (int)result;
77416   return jresult;
77417 }
77418
77419
77420 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_FONT_STYLE_get() {
77421   int jresult ;
77422   int result;
77423
77424   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77425   jresult = (int)result;
77426   return jresult;
77427 }
77428
77429
77430 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_POINT_SIZE_get() {
77431   int jresult ;
77432   int result;
77433
77434   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77435   jresult = (int)result;
77436   return jresult;
77437 }
77438
77439
77440 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77441   int jresult ;
77442   int result;
77443
77444   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77445   jresult = (int)result;
77446   return jresult;
77447 }
77448
77449
77450 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SCROLL_THRESHOLD_get() {
77451   int jresult ;
77452   int result;
77453
77454   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77455   jresult = (int)result;
77456   return jresult;
77457 }
77458
77459
77460 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SCROLL_SPEED_get() {
77461   int jresult ;
77462   int result;
77463
77464   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77465   jresult = (int)result;
77466   return jresult;
77467 }
77468
77469
77470 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77471   int jresult ;
77472   int result;
77473
77474   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77475   jresult = (int)result;
77476   return jresult;
77477 }
77478
77479
77480 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77481   int jresult ;
77482   int result;
77483
77484   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77485   jresult = (int)result;
77486   return jresult;
77487 }
77488
77489
77490 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77491   int jresult ;
77492   int result;
77493
77494   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77495   jresult = (int)result;
77496   return jresult;
77497 }
77498
77499
77500 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77501   int jresult ;
77502   int result;
77503
77504   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77505   jresult = (int)result;
77506   return jresult;
77507 }
77508
77509
77510 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77511   int jresult ;
77512   int result;
77513
77514   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77515   jresult = (int)result;
77516   return jresult;
77517 }
77518
77519
77520 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_CURSOR_WIDTH_get() {
77521   int jresult ;
77522   int result;
77523
77524   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77525   jresult = (int)result;
77526   return jresult;
77527 }
77528
77529
77530 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77531   int jresult ;
77532   int result;
77533
77534   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77535   jresult = (int)result;
77536   return jresult;
77537 }
77538
77539
77540 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77541   int jresult ;
77542   int result;
77543
77544   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77545   jresult = (int)result;
77546   return jresult;
77547 }
77548
77549
77550 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77551   int jresult ;
77552   int result;
77553
77554   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77555   jresult = (int)result;
77556   return jresult;
77557 }
77558
77559
77560 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77561   int jresult ;
77562   int result;
77563
77564   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77565   jresult = (int)result;
77566   return jresult;
77567 }
77568
77569
77570 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77571   int jresult ;
77572   int result;
77573
77574   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77575   jresult = (int)result;
77576   return jresult;
77577 }
77578
77579
77580 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77581   int jresult ;
77582   int result;
77583
77584   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77585   jresult = (int)result;
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77591   int jresult ;
77592   int result;
77593
77594   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77595   jresult = (int)result;
77596   return jresult;
77597 }
77598
77599
77600 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77601   int jresult ;
77602   int result;
77603
77604   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77605   jresult = (int)result;
77606   return jresult;
77607 }
77608
77609
77610 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77611   int jresult ;
77612   int result;
77613
77614   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77615   jresult = (int)result;
77616   return jresult;
77617 }
77618
77619
77620 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77621   int jresult ;
77622   int result;
77623
77624   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77625   jresult = (int)result;
77626   return jresult;
77627 }
77628
77629
77630 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_ENABLE_MARKUP_get() {
77631   int jresult ;
77632   int result;
77633
77634   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77635   jresult = (int)result;
77636   return jresult;
77637 }
77638
77639
77640 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_COLOR_get() {
77641   int jresult ;
77642   int result;
77643
77644   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77645   jresult = (int)result;
77646   return jresult;
77647 }
77648
77649
77650 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77651   int jresult ;
77652   int result;
77653
77654   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77655   jresult = (int)result;
77656   return jresult;
77657 }
77658
77659
77660 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_FONT_STYLE_get() {
77661   int jresult ;
77662   int result;
77663
77664   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77665   jresult = (int)result;
77666   return jresult;
77667 }
77668
77669
77670 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_POINT_SIZE_get() {
77671   int jresult ;
77672   int result;
77673
77674   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77675   jresult = (int)result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_LINE_SPACING_get() {
77681   int jresult ;
77682   int result;
77683
77684   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77685   jresult = (int)result;
77686   return jresult;
77687 }
77688
77689
77690 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_LINE_SPACING_get() {
77691   int jresult ;
77692   int result;
77693
77694   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77695   jresult = (int)result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_UNDERLINE_get() {
77701   int jresult ;
77702   int result;
77703
77704   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77705   jresult = (int)result;
77706   return jresult;
77707 }
77708
77709
77710 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_UNDERLINE_get() {
77711   int jresult ;
77712   int result;
77713
77714   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77715   jresult = (int)result;
77716   return jresult;
77717 }
77718
77719
77720 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_SHADOW_get() {
77721   int jresult ;
77722   int result;
77723
77724   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77725   jresult = (int)result;
77726   return jresult;
77727 }
77728
77729
77730 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_SHADOW_get() {
77731   int jresult ;
77732   int result;
77733
77734   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77735   jresult = (int)result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_EMBOSS_get() {
77741   int jresult ;
77742   int result;
77743
77744   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77745   jresult = (int)result;
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_EMBOSS_get() {
77751   int jresult ;
77752   int result;
77753
77754   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77755   jresult = (int)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_OUTLINE_get() {
77761   int jresult ;
77762   int result;
77763
77764   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77765   jresult = (int)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextEditor_Property_INPUT_OUTLINE_get() {
77771   int jresult ;
77772   int result;
77773
77774   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77775   jresult = (int)result;
77776   return jresult;
77777 }
77778
77779
77780 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor_Property() {
77781   void * jresult ;
77782   Dali::Toolkit::TextEditor::Property *result = 0 ;
77783
77784   {
77785     try {
77786       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77787     } catch (std::out_of_range& e) {
77788       {
77789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77790       };
77791     } catch (std::exception& e) {
77792       {
77793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77794       };
77795     } catch (...) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77798       };
77799     }
77800   }
77801   jresult = (void *)result;
77802   return jresult;
77803 }
77804
77805
77806 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor_Property(void * jarg1) {
77807   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77808
77809   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77810   {
77811     try {
77812       delete arg1;
77813     } catch (std::out_of_range& e) {
77814       {
77815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77816       };
77817     } catch (std::exception& e) {
77818       {
77819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77820       };
77821     } catch (...) {
77822       {
77823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77824       };
77825     }
77826   }
77827 }
77828
77829
77830 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor_InputStyle() {
77831   void * jresult ;
77832   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77833
77834   {
77835     try {
77836       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77837     } catch (std::out_of_range& e) {
77838       {
77839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77840       };
77841     } catch (std::exception& e) {
77842       {
77843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77844       };
77845     } catch (...) {
77846       {
77847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77848       };
77849     }
77850   }
77851   jresult = (void *)result;
77852   return jresult;
77853 }
77854
77855
77856 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor_InputStyle(void * jarg1) {
77857   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77858
77859   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77860   {
77861     try {
77862       delete arg1;
77863     } catch (std::out_of_range& e) {
77864       {
77865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77866       };
77867     } catch (std::exception& e) {
77868       {
77869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77870       };
77871     } catch (...) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77874       };
77875     }
77876   }
77877 }
77878
77879
77880 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_New() {
77881   void * jresult ;
77882   Dali::Toolkit::TextEditor result;
77883
77884   {
77885     try {
77886       result = Dali::Toolkit::TextEditor::New();
77887     } catch (std::out_of_range& e) {
77888       {
77889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (std::exception& e) {
77892       {
77893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77894       };
77895     } catch (...) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77898       };
77899     }
77900   }
77901   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77902   return jresult;
77903 }
77904
77905
77906 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor__SWIG_0() {
77907   void * jresult ;
77908   Dali::Toolkit::TextEditor *result = 0 ;
77909
77910   {
77911     try {
77912       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77913     } catch (std::out_of_range& e) {
77914       {
77915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (std::exception& e) {
77918       {
77919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (...) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77924       };
77925     }
77926   }
77927   jresult = (void *)result;
77928   return jresult;
77929 }
77930
77931
77932 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditor__SWIG_1(void * jarg1) {
77933   void * jresult ;
77934   Dali::Toolkit::TextEditor *arg1 = 0 ;
77935   Dali::Toolkit::TextEditor *result = 0 ;
77936
77937   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77938   if (!arg1) {
77939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77940     return 0;
77941   }
77942   {
77943     try {
77944       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77945     } catch (std::out_of_range& e) {
77946       {
77947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (std::exception& e) {
77950       {
77951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77952       };
77953     } catch (...) {
77954       {
77955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77956       };
77957     }
77958   }
77959   jresult = (void *)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_Assign(void * jarg1, void * jarg2) {
77965   void * jresult ;
77966   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77967   Dali::Toolkit::TextEditor *arg2 = 0 ;
77968   Dali::Toolkit::TextEditor *result = 0 ;
77969
77970   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77971   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77972   if (!arg2) {
77973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77974     return 0;
77975   }
77976   {
77977     try {
77978       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77979     } catch (std::out_of_range& e) {
77980       {
77981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77982       };
77983     } catch (std::exception& e) {
77984       {
77985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77986       };
77987     } catch (...) {
77988       {
77989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77990       };
77991     }
77992   }
77993   jresult = (void *)result;
77994   return jresult;
77995 }
77996
77997
77998 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditor(void * jarg1) {
77999   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78000
78001   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78002   {
78003     try {
78004       delete arg1;
78005     } catch (std::out_of_range& e) {
78006       {
78007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78008       };
78009     } catch (std::exception& e) {
78010       {
78011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78016       };
78017     }
78018   }
78019 }
78020
78021
78022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_DownCast(void * jarg1) {
78023   void * jresult ;
78024   Dali::BaseHandle arg1 ;
78025   Dali::BaseHandle *argp1 ;
78026   Dali::Toolkit::TextEditor result;
78027
78028   argp1 = (Dali::BaseHandle *)jarg1;
78029   if (!argp1) {
78030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78031     return 0;
78032   }
78033   arg1 = *argp1;
78034   {
78035     try {
78036       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78037     } catch (std::out_of_range& e) {
78038       {
78039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78040       };
78041     } catch (std::exception& e) {
78042       {
78043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78048       };
78049     }
78050   }
78051   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_TextChangedSignal(void * jarg1) {
78057   void * jresult ;
78058   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78059   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78060
78061   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78062   {
78063     try {
78064       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (...) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78076       };
78077     }
78078   }
78079   jresult = (void *)result;
78080   return jresult;
78081 }
78082
78083
78084 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextEditor_InputStyleChangedSignal(void * jarg1) {
78085   void * jresult ;
78086   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78087   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78088
78089   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78090   {
78091     try {
78092       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78093     } catch (std::out_of_range& e) {
78094       {
78095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78096       };
78097     } catch (std::exception& e) {
78098       {
78099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78100       };
78101     } catch (...) {
78102       {
78103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78104       };
78105     }
78106   }
78107   jresult = (void *)result;
78108   return jresult;
78109 }
78110
78111
78112 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_RENDERING_BACKEND_get() {
78113   int jresult ;
78114   int result;
78115
78116   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78117   jresult = (int)result;
78118   return jresult;
78119 }
78120
78121
78122 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_TEXT_get() {
78123   int jresult ;
78124   int result;
78125
78126   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78127   jresult = (int)result;
78128   return jresult;
78129 }
78130
78131
78132 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_get() {
78133   int jresult ;
78134   int result;
78135
78136   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78137   jresult = (int)result;
78138   return jresult;
78139 }
78140
78141
78142 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78143   int jresult ;
78144   int result;
78145
78146   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78147   jresult = (int)result;
78148   return jresult;
78149 }
78150
78151
78152 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_FONT_FAMILY_get() {
78153   int jresult ;
78154   int result;
78155
78156   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78157   jresult = (int)result;
78158   return jresult;
78159 }
78160
78161
78162 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_FONT_STYLE_get() {
78163   int jresult ;
78164   int result;
78165
78166   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78167   jresult = (int)result;
78168   return jresult;
78169 }
78170
78171
78172 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_POINT_SIZE_get() {
78173   int jresult ;
78174   int result;
78175
78176   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78177   jresult = (int)result;
78178   return jresult;
78179 }
78180
78181
78182 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_MAX_LENGTH_get() {
78183   int jresult ;
78184   int result;
78185
78186   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78187   jresult = (int)result;
78188   return jresult;
78189 }
78190
78191
78192 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_EXCEED_POLICY_get() {
78193   int jresult ;
78194   int result;
78195
78196   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78197   jresult = (int)result;
78198   return jresult;
78199 }
78200
78201
78202 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78203   int jresult ;
78204   int result;
78205
78206   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78207   jresult = (int)result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_VERTICAL_ALIGNMENT_get() {
78213   int jresult ;
78214   int result;
78215
78216   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78217   jresult = (int)result;
78218   return jresult;
78219 }
78220
78221
78222 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_TEXT_COLOR_get() {
78223   int jresult ;
78224   int result;
78225
78226   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78227   jresult = (int)result;
78228   return jresult;
78229 }
78230
78231
78232 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78233   int jresult ;
78234   int result;
78235
78236   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78237   jresult = (int)result;
78238   return jresult;
78239 }
78240
78241
78242 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_OFFSET_get() {
78243   int jresult ;
78244   int result;
78245
78246   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78247   jresult = (int)result;
78248   return jresult;
78249 }
78250
78251
78252 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_COLOR_get() {
78253   int jresult ;
78254   int result;
78255
78256   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78257   jresult = (int)result;
78258   return jresult;
78259 }
78260
78261
78262 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78263   int jresult ;
78264   int result;
78265
78266   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78267   jresult = (int)result;
78268   return jresult;
78269 }
78270
78271
78272 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78273   int jresult ;
78274   int result;
78275
78276   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78277   jresult = (int)result;
78278   return jresult;
78279 }
78280
78281
78282 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78283   int jresult ;
78284   int result;
78285
78286   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78287   jresult = (int)result;
78288   return jresult;
78289 }
78290
78291
78292 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78293   int jresult ;
78294   int result;
78295
78296   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78297   jresult = (int)result;
78298   return jresult;
78299 }
78300
78301
78302 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_BLINK_DURATION_get() {
78303   int jresult ;
78304   int result;
78305
78306   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78307   jresult = (int)result;
78308   return jresult;
78309 }
78310
78311
78312 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_CURSOR_WIDTH_get() {
78313   int jresult ;
78314   int result;
78315
78316   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78317   jresult = (int)result;
78318   return jresult;
78319 }
78320
78321
78322 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78323   int jresult ;
78324   int result;
78325
78326   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78327   jresult = (int)result;
78328   return jresult;
78329 }
78330
78331
78332 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78333   int jresult ;
78334   int result;
78335
78336   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78337   jresult = (int)result;
78338   return jresult;
78339 }
78340
78341
78342 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SCROLL_THRESHOLD_get() {
78343   int jresult ;
78344   int result;
78345
78346   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78347   jresult = (int)result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SCROLL_SPEED_get() {
78353   int jresult ;
78354   int result;
78355
78356   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78357   jresult = (int)result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78363   int jresult ;
78364   int result;
78365
78366   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78367   jresult = (int)result;
78368   return jresult;
78369 }
78370
78371
78372 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78373   int jresult ;
78374   int result;
78375
78376   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78377   jresult = (int)result;
78378   return jresult;
78379 }
78380
78381
78382 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78383   int jresult ;
78384   int result;
78385
78386   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78387   jresult = (int)result;
78388   return jresult;
78389 }
78390
78391
78392 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78393   int jresult ;
78394   int result;
78395
78396   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78397   jresult = (int)result;
78398   return jresult;
78399 }
78400
78401
78402 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78403   int jresult ;
78404   int result;
78405
78406   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78407   jresult = (int)result;
78408   return jresult;
78409 }
78410
78411
78412 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78413   int jresult ;
78414   int result;
78415
78416   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78417   jresult = (int)result;
78418   return jresult;
78419 }
78420
78421
78422 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78423   int jresult ;
78424   int result;
78425
78426   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78427   jresult = (int)result;
78428   return jresult;
78429 }
78430
78431
78432 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78433   int jresult ;
78434   int result;
78435
78436   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78437   jresult = (int)result;
78438   return jresult;
78439 }
78440
78441
78442 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78443   int jresult ;
78444   int result;
78445
78446   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78447   jresult = (int)result;
78448   return jresult;
78449 }
78450
78451
78452 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_COLOR_get() {
78453   int jresult ;
78454   int result;
78455
78456   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78457   jresult = (int)result;
78458   return jresult;
78459 }
78460
78461
78462 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_ENABLE_MARKUP_get() {
78463   int jresult ;
78464   int result;
78465
78466   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78467   jresult = (int)result;
78468   return jresult;
78469 }
78470
78471
78472 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_FONT_FAMILY_get() {
78473   int jresult ;
78474   int result;
78475
78476   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78477   jresult = (int)result;
78478   return jresult;
78479 }
78480
78481
78482 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_FONT_STYLE_get() {
78483   int jresult ;
78484   int result;
78485
78486   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78487   jresult = (int)result;
78488   return jresult;
78489 }
78490
78491
78492 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_POINT_SIZE_get() {
78493   int jresult ;
78494   int result;
78495
78496   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78497   jresult = (int)result;
78498   return jresult;
78499 }
78500
78501
78502 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_UNDERLINE_get() {
78503   int jresult ;
78504   int result;
78505
78506   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78507   jresult = (int)result;
78508   return jresult;
78509 }
78510
78511
78512 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_UNDERLINE_get() {
78513   int jresult ;
78514   int result;
78515
78516   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78517   jresult = (int)result;
78518   return jresult;
78519 }
78520
78521
78522 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_SHADOW_get() {
78523   int jresult ;
78524   int result;
78525
78526   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78527   jresult = (int)result;
78528   return jresult;
78529 }
78530
78531
78532 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_SHADOW_get() {
78533   int jresult ;
78534   int result;
78535
78536   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78537   jresult = (int)result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_EMBOSS_get() {
78543   int jresult ;
78544   int result;
78545
78546   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78547   jresult = (int)result;
78548   return jresult;
78549 }
78550
78551
78552 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_EMBOSS_get() {
78553   int jresult ;
78554   int result;
78555
78556   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78557   jresult = (int)result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_OUTLINE_get() {
78563   int jresult ;
78564   int result;
78565
78566   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78567   jresult = (int)result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextField_Property_INPUT_OUTLINE_get() {
78573   int jresult ;
78574   int result;
78575
78576   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78577   jresult = (int)result;
78578   return jresult;
78579 }
78580
78581
78582 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField_Property() {
78583   void * jresult ;
78584   Dali::Toolkit::TextField::Property *result = 0 ;
78585
78586   {
78587     try {
78588       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78589     } catch (std::out_of_range& e) {
78590       {
78591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78592       };
78593     } catch (std::exception& e) {
78594       {
78595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78596       };
78597     } catch (...) {
78598       {
78599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78600       };
78601     }
78602   }
78603   jresult = (void *)result;
78604   return jresult;
78605 }
78606
78607
78608 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField_Property(void * jarg1) {
78609   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78610
78611   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78612   {
78613     try {
78614       delete arg1;
78615     } catch (std::out_of_range& e) {
78616       {
78617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78618       };
78619     } catch (std::exception& e) {
78620       {
78621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78622       };
78623     } catch (...) {
78624       {
78625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78626       };
78627     }
78628   }
78629 }
78630
78631
78632 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField_InputStyle() {
78633   void * jresult ;
78634   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78635
78636   {
78637     try {
78638       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78639     } catch (std::out_of_range& e) {
78640       {
78641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78642       };
78643     } catch (std::exception& e) {
78644       {
78645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78646       };
78647     } catch (...) {
78648       {
78649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78650       };
78651     }
78652   }
78653   jresult = (void *)result;
78654   return jresult;
78655 }
78656
78657
78658 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField_InputStyle(void * jarg1) {
78659   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78660
78661   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78662   {
78663     try {
78664       delete arg1;
78665     } catch (std::out_of_range& e) {
78666       {
78667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78668       };
78669     } catch (std::exception& e) {
78670       {
78671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78672       };
78673     } catch (...) {
78674       {
78675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78676       };
78677     }
78678   }
78679 }
78680
78681
78682 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_New() {
78683   void * jresult ;
78684   Dali::Toolkit::TextField result;
78685
78686   {
78687     try {
78688       result = Dali::Toolkit::TextField::New();
78689     } catch (std::out_of_range& e) {
78690       {
78691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78692       };
78693     } catch (std::exception& e) {
78694       {
78695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78696       };
78697     } catch (...) {
78698       {
78699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78700       };
78701     }
78702   }
78703   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78704   return jresult;
78705 }
78706
78707
78708 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField__SWIG_0() {
78709   void * jresult ;
78710   Dali::Toolkit::TextField *result = 0 ;
78711
78712   {
78713     try {
78714       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78715     } catch (std::out_of_range& e) {
78716       {
78717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78718       };
78719     } catch (std::exception& e) {
78720       {
78721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78722       };
78723     } catch (...) {
78724       {
78725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78726       };
78727     }
78728   }
78729   jresult = (void *)result;
78730   return jresult;
78731 }
78732
78733
78734 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextField__SWIG_1(void * jarg1) {
78735   void * jresult ;
78736   Dali::Toolkit::TextField *arg1 = 0 ;
78737   Dali::Toolkit::TextField *result = 0 ;
78738
78739   arg1 = (Dali::Toolkit::TextField *)jarg1;
78740   if (!arg1) {
78741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78742     return 0;
78743   }
78744   {
78745     try {
78746       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78747     } catch (std::out_of_range& e) {
78748       {
78749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (std::exception& e) {
78752       {
78753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78754       };
78755     } catch (...) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78758       };
78759     }
78760   }
78761   jresult = (void *)result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_Assign(void * jarg1, void * jarg2) {
78767   void * jresult ;
78768   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78769   Dali::Toolkit::TextField *arg2 = 0 ;
78770   Dali::Toolkit::TextField *result = 0 ;
78771
78772   arg1 = (Dali::Toolkit::TextField *)jarg1;
78773   arg2 = (Dali::Toolkit::TextField *)jarg2;
78774   if (!arg2) {
78775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78776     return 0;
78777   }
78778   {
78779     try {
78780       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78781     } catch (std::out_of_range& e) {
78782       {
78783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78784       };
78785     } catch (std::exception& e) {
78786       {
78787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78788       };
78789     } catch (...) {
78790       {
78791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78792       };
78793     }
78794   }
78795   jresult = (void *)result;
78796   return jresult;
78797 }
78798
78799
78800 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextField(void * jarg1) {
78801   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78802
78803   arg1 = (Dali::Toolkit::TextField *)jarg1;
78804   {
78805     try {
78806       delete arg1;
78807     } catch (std::out_of_range& e) {
78808       {
78809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78810       };
78811     } catch (std::exception& e) {
78812       {
78813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78814       };
78815     } catch (...) {
78816       {
78817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78818       };
78819     }
78820   }
78821 }
78822
78823
78824 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_DownCast(void * jarg1) {
78825   void * jresult ;
78826   Dali::BaseHandle arg1 ;
78827   Dali::BaseHandle *argp1 ;
78828   Dali::Toolkit::TextField result;
78829
78830   argp1 = (Dali::BaseHandle *)jarg1;
78831   if (!argp1) {
78832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78833     return 0;
78834   }
78835   arg1 = *argp1;
78836   {
78837     try {
78838       result = Dali::Toolkit::TextField::DownCast(arg1);
78839     } catch (std::out_of_range& e) {
78840       {
78841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78842       };
78843     } catch (std::exception& e) {
78844       {
78845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78850       };
78851     }
78852   }
78853   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_TextChangedSignal(void * jarg1) {
78859   void * jresult ;
78860   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78861   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78862
78863   arg1 = (Dali::Toolkit::TextField *)jarg1;
78864   {
78865     try {
78866       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78867     } catch (std::out_of_range& e) {
78868       {
78869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (std::exception& e) {
78872       {
78873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (...) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78878       };
78879     }
78880   }
78881   jresult = (void *)result;
78882   return jresult;
78883 }
78884
78885
78886 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_MaxLengthReachedSignal(void * jarg1) {
78887   void * jresult ;
78888   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78889   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78890
78891   arg1 = (Dali::Toolkit::TextField *)jarg1;
78892   {
78893     try {
78894       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78895     } catch (std::out_of_range& e) {
78896       {
78897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78898       };
78899     } catch (std::exception& e) {
78900       {
78901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78902       };
78903     } catch (...) {
78904       {
78905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78906       };
78907     }
78908   }
78909   jresult = (void *)result;
78910   return jresult;
78911 }
78912
78913
78914 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextField_InputStyleChangedSignal(void * jarg1) {
78915   void * jresult ;
78916   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78917   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78918
78919   arg1 = (Dali::Toolkit::TextField *)jarg1;
78920   {
78921     try {
78922       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78923     } catch (std::out_of_range& e) {
78924       {
78925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78926       };
78927     } catch (std::exception& e) {
78928       {
78929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78930       };
78931     } catch (...) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78934       };
78935     }
78936   }
78937   jresult = (void *)result;
78938   return jresult;
78939 }
78940
78941
78942 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_RENDERING_BACKEND_get() {
78943   int jresult ;
78944   int result;
78945
78946   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78947   jresult = (int)result;
78948   return jresult;
78949 }
78950
78951
78952 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_TEXT_get() {
78953   int jresult ;
78954   int result;
78955
78956   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78957   jresult = (int)result;
78958   return jresult;
78959 }
78960
78961
78962 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_FONT_FAMILY_get() {
78963   int jresult ;
78964   int result;
78965
78966   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78967   jresult = (int)result;
78968   return jresult;
78969 }
78970
78971
78972 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_FONT_STYLE_get() {
78973   int jresult ;
78974   int result;
78975
78976   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78977   jresult = (int)result;
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_POINT_SIZE_get() {
78983   int jresult ;
78984   int result;
78985
78986   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78987   jresult = (int)result;
78988   return jresult;
78989 }
78990
78991
78992 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_MULTI_LINE_get() {
78993   int jresult ;
78994   int result;
78995
78996   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78997   jresult = (int)result;
78998   return jresult;
78999 }
79000
79001
79002 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79003   int jresult ;
79004   int result;
79005
79006   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79007   jresult = (int)result;
79008   return jresult;
79009 }
79010
79011
79012 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79013   int jresult ;
79014   int result;
79015
79016   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79017   jresult = (int)result;
79018   return jresult;
79019 }
79020
79021
79022 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_TEXT_COLOR_get() {
79023   int jresult ;
79024   int result;
79025
79026   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79027   jresult = (int)result;
79028   return jresult;
79029 }
79030
79031
79032 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_OFFSET_get() {
79033   int jresult ;
79034   int result;
79035
79036   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79037   jresult = (int)result;
79038   return jresult;
79039 }
79040
79041
79042 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_COLOR_get() {
79043   int jresult ;
79044   int result;
79045
79046   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79047   jresult = (int)result;
79048   return jresult;
79049 }
79050
79051
79052 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_ENABLED_get() {
79053   int jresult ;
79054   int result;
79055
79056   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79057   jresult = (int)result;
79058   return jresult;
79059 }
79060
79061
79062 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_COLOR_get() {
79063   int jresult ;
79064   int result;
79065
79066   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79067   jresult = (int)result;
79068   return jresult;
79069 }
79070
79071
79072 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79073   int jresult ;
79074   int result;
79075
79076   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79077   jresult = (int)result;
79078   return jresult;
79079 }
79080
79081
79082 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_ENABLE_MARKUP_get() {
79083   int jresult ;
79084   int result;
79085
79086   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79087   jresult = (int)result;
79088   return jresult;
79089 }
79090
79091
79092 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79093   int jresult ;
79094   int result;
79095
79096   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79097   jresult = (int)result;
79098   return jresult;
79099 }
79100
79101
79102 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79103   int jresult ;
79104   int result;
79105
79106   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79107   jresult = (int)result;
79108   return jresult;
79109 }
79110
79111
79112 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79113   int jresult ;
79114   int result;
79115
79116   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79117   jresult = (int)result;
79118   return jresult;
79119 }
79120
79121
79122 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79123   int jresult ;
79124   int result;
79125
79126   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79127   jresult = (int)result;
79128   return jresult;
79129 }
79130
79131
79132 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_LINE_SPACING_get() {
79133   int jresult ;
79134   int result;
79135
79136   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79137   jresult = (int)result;
79138   return jresult;
79139 }
79140
79141
79142 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_UNDERLINE_get() {
79143   int jresult ;
79144   int result;
79145
79146   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79147   jresult = (int)result;
79148   return jresult;
79149 }
79150
79151
79152 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_SHADOW_get() {
79153   int jresult ;
79154   int result;
79155
79156   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79157   jresult = (int)result;
79158   return jresult;
79159 }
79160
79161
79162 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_EMBOSS_get() {
79163   int jresult ;
79164   int result;
79165
79166   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79167   jresult = (int)result;
79168   return jresult;
79169 }
79170
79171
79172 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_TextLabel_Property_OUTLINE_get() {
79173   int jresult ;
79174   int result;
79175
79176   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79177   jresult = (int)result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel_Property() {
79183   void * jresult ;
79184   Dali::Toolkit::TextLabel::Property *result = 0 ;
79185
79186   {
79187     try {
79188       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79189     } catch (std::out_of_range& e) {
79190       {
79191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79192       };
79193     } catch (std::exception& e) {
79194       {
79195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79196       };
79197     } catch (...) {
79198       {
79199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79200       };
79201     }
79202   }
79203   jresult = (void *)result;
79204   return jresult;
79205 }
79206
79207
79208 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextLabel_Property(void * jarg1) {
79209   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79210
79211   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79212   {
79213     try {
79214       delete arg1;
79215     } catch (std::out_of_range& e) {
79216       {
79217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79218       };
79219     } catch (std::exception& e) {
79220       {
79221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79222       };
79223     } catch (...) {
79224       {
79225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79226       };
79227     }
79228   }
79229 }
79230
79231
79232 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_New__SWIG_0() {
79233   void * jresult ;
79234   Dali::Toolkit::TextLabel result;
79235
79236   {
79237     try {
79238       result = Dali::Toolkit::TextLabel::New();
79239     } catch (std::out_of_range& e) {
79240       {
79241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79242       };
79243     } catch (std::exception& e) {
79244       {
79245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79246       };
79247     } catch (...) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79250       };
79251     }
79252   }
79253   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79254   return jresult;
79255 }
79256
79257
79258 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_New__SWIG_1(char * jarg1) {
79259   void * jresult ;
79260   std::string *arg1 = 0 ;
79261   Dali::Toolkit::TextLabel result;
79262
79263   if (!jarg1) {
79264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79265     return 0;
79266   }
79267   std::string arg1_str(jarg1);
79268   arg1 = &arg1_str;
79269   {
79270     try {
79271       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79272     } catch (std::out_of_range& e) {
79273       {
79274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (std::exception& e) {
79277       {
79278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79279       };
79280     } catch (...) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79283       };
79284     }
79285   }
79286   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79287
79288   //argout typemap for const std::string&
79289
79290   return jresult;
79291 }
79292
79293
79294 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel__SWIG_0() {
79295   void * jresult ;
79296   Dali::Toolkit::TextLabel *result = 0 ;
79297
79298   {
79299     try {
79300       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79301     } catch (std::out_of_range& e) {
79302       {
79303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (std::exception& e) {
79306       {
79307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79308       };
79309     } catch (...) {
79310       {
79311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79312       };
79313     }
79314   }
79315   jresult = (void *)result;
79316   return jresult;
79317 }
79318
79319
79320 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextLabel__SWIG_1(void * jarg1) {
79321   void * jresult ;
79322   Dali::Toolkit::TextLabel *arg1 = 0 ;
79323   Dali::Toolkit::TextLabel *result = 0 ;
79324
79325   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79326   if (!arg1) {
79327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79328     return 0;
79329   }
79330   {
79331     try {
79332       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79340       };
79341     } catch (...) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79344       };
79345     }
79346   }
79347   jresult = (void *)result;
79348   return jresult;
79349 }
79350
79351
79352 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_Assign(void * jarg1, void * jarg2) {
79353   void * jresult ;
79354   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79355   Dali::Toolkit::TextLabel *arg2 = 0 ;
79356   Dali::Toolkit::TextLabel *result = 0 ;
79357
79358   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79359   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79360   if (!arg2) {
79361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79362     return 0;
79363   }
79364   {
79365     try {
79366       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79367     } catch (std::out_of_range& e) {
79368       {
79369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79370       };
79371     } catch (std::exception& e) {
79372       {
79373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79374       };
79375     } catch (...) {
79376       {
79377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79378       };
79379     }
79380   }
79381   jresult = (void *)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextLabel(void * jarg1) {
79387   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79388
79389   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79390   {
79391     try {
79392       delete arg1;
79393     } catch (std::out_of_range& e) {
79394       {
79395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79396       };
79397     } catch (std::exception& e) {
79398       {
79399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79400       };
79401     } catch (...) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79404       };
79405     }
79406   }
79407 }
79408
79409
79410 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_TextLabel_DownCast(void * jarg1) {
79411   void * jresult ;
79412   Dali::BaseHandle arg1 ;
79413   Dali::BaseHandle *argp1 ;
79414   Dali::Toolkit::TextLabel result;
79415
79416   argp1 = (Dali::BaseHandle *)jarg1;
79417   if (!argp1) {
79418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79419     return 0;
79420   }
79421   arg1 = *argp1;
79422   {
79423     try {
79424       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79425     } catch (std::out_of_range& e) {
79426       {
79427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79428       };
79429     } catch (std::exception& e) {
79430       {
79431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79432       };
79433     } catch (...) {
79434       {
79435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79436       };
79437     }
79438   }
79439   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79440   return jresult;
79441 }
79442
79443
79444 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityManager() {
79445   void * jresult ;
79446   Dali::Toolkit::AccessibilityManager *result = 0 ;
79447
79448   {
79449     try {
79450       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79451     } catch (std::out_of_range& e) {
79452       {
79453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (std::exception& e) {
79456       {
79457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465   jresult = (void *)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityManager(void * jarg1) {
79471   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79472
79473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79474   {
79475     try {
79476       delete arg1;
79477     } catch (std::out_of_range& e) {
79478       {
79479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79480       };
79481     } catch (std::exception& e) {
79482       {
79483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79484       };
79485     } catch (...) {
79486       {
79487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79488       };
79489     }
79490   }
79491 }
79492
79493
79494 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_Get() {
79495   void * jresult ;
79496   Dali::Toolkit::AccessibilityManager result;
79497
79498   {
79499     try {
79500       result = Dali::Toolkit::AccessibilityManager::Get();
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79522   Dali::Actor arg2 ;
79523   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79524   std::string *arg4 = 0 ;
79525   Dali::Actor *argp2 ;
79526
79527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79528   argp2 = (Dali::Actor *)jarg2;
79529   if (!argp2) {
79530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79531     return ;
79532   }
79533   arg2 = *argp2;
79534   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79535   if (!jarg4) {
79536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79537     return ;
79538   }
79539   std::string arg4_str(jarg4);
79540   arg4 = &arg4_str;
79541   {
79542     try {
79543       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79544     } catch (std::out_of_range& e) {
79545       {
79546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79547       };
79548     } catch (std::exception& e) {
79549       {
79550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79551       };
79552     } catch (...) {
79553       {
79554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79555       };
79556     }
79557   }
79558
79559   //argout typemap for const std::string&
79560
79561 }
79562
79563
79564 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79565   char * jresult ;
79566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79567   Dali::Actor arg2 ;
79568   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79569   Dali::Actor *argp2 ;
79570   std::string result;
79571
79572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79573   argp2 = (Dali::Actor *)jarg2;
79574   if (!argp2) {
79575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79576     return 0;
79577   }
79578   arg2 = *argp2;
79579   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79580   {
79581     try {
79582       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79583     } catch (std::out_of_range& e) {
79584       {
79585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79586       };
79587     } catch (std::exception& e) {
79588       {
79589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79590       };
79591     } catch (...) {
79592       {
79593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79594       };
79595     }
79596   }
79597   jresult = SWIG_csharp_string_callback((&result)->c_str());
79598   return jresult;
79599 }
79600
79601
79602 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79603   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79604   Dali::Actor arg2 ;
79605   unsigned int arg3 ;
79606   Dali::Actor *argp2 ;
79607
79608   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79609   argp2 = (Dali::Actor *)jarg2;
79610   if (!argp2) {
79611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79612     return ;
79613   }
79614   arg2 = *argp2;
79615   arg3 = (unsigned int)jarg3;
79616   {
79617     try {
79618       (arg1)->SetFocusOrder(arg2,arg3);
79619     } catch (std::out_of_range& e) {
79620       {
79621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79622       };
79623     } catch (std::exception& e) {
79624       {
79625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79626       };
79627     } catch (...) {
79628       {
79629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79630       };
79631     }
79632   }
79633 }
79634
79635
79636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79637   unsigned int jresult ;
79638   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79639   Dali::Actor arg2 ;
79640   Dali::Actor *argp2 ;
79641   unsigned int result;
79642
79643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79644   argp2 = (Dali::Actor *)jarg2;
79645   if (!argp2) {
79646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79647     return 0;
79648   }
79649   arg2 = *argp2;
79650   {
79651     try {
79652       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79653     } catch (std::out_of_range& e) {
79654       {
79655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (std::exception& e) {
79658       {
79659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79664       };
79665     }
79666   }
79667   jresult = result;
79668   return jresult;
79669 }
79670
79671
79672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79673   unsigned int jresult ;
79674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79675   unsigned int result;
79676
79677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79678   {
79679     try {
79680       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79681     } catch (std::out_of_range& e) {
79682       {
79683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (std::exception& e) {
79686       {
79687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79688       };
79689     } catch (...) {
79690       {
79691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79692       };
79693     }
79694   }
79695   jresult = result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79701   void * jresult ;
79702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79703   unsigned int arg2 ;
79704   Dali::Actor result;
79705
79706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79707   arg2 = (unsigned int)jarg2;
79708   {
79709     try {
79710       result = (arg1)->GetActorByFocusOrder(arg2);
79711     } catch (std::out_of_range& e) {
79712       {
79713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79714       };
79715     } catch (std::exception& e) {
79716       {
79717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79718       };
79719     } catch (...) {
79720       {
79721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79722       };
79723     }
79724   }
79725   jresult = new Dali::Actor((const Dali::Actor &)result);
79726   return jresult;
79727 }
79728
79729
79730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79731   unsigned int jresult ;
79732   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79733   Dali::Actor arg2 ;
79734   Dali::Actor *argp2 ;
79735   bool result;
79736
79737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79738   argp2 = (Dali::Actor *)jarg2;
79739   if (!argp2) {
79740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79741     return 0;
79742   }
79743   arg2 = *argp2;
79744   {
79745     try {
79746       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79747     } catch (std::out_of_range& e) {
79748       {
79749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79750       };
79751     } catch (std::exception& e) {
79752       {
79753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79754       };
79755     } catch (...) {
79756       {
79757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79758       };
79759     }
79760   }
79761   jresult = result;
79762   return jresult;
79763 }
79764
79765
79766 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79767   void * jresult ;
79768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79769   Dali::Actor result;
79770
79771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79772   {
79773     try {
79774       result = (arg1)->GetCurrentFocusActor();
79775     } catch (std::out_of_range& e) {
79776       {
79777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79778       };
79779     } catch (std::exception& e) {
79780       {
79781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79782       };
79783     } catch (...) {
79784       {
79785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79786       };
79787     }
79788   }
79789   jresult = new Dali::Actor((const Dali::Actor &)result);
79790   return jresult;
79791 }
79792
79793
79794 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79795   void * jresult ;
79796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79797   Dali::Actor result;
79798
79799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79800   {
79801     try {
79802       result = (arg1)->GetCurrentFocusGroup();
79803     } catch (std::out_of_range& e) {
79804       {
79805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79806       };
79807     } catch (std::exception& e) {
79808       {
79809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (...) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79814       };
79815     }
79816   }
79817   jresult = new Dali::Actor((const Dali::Actor &)result);
79818   return jresult;
79819 }
79820
79821
79822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79823   unsigned int jresult ;
79824   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79825   unsigned int result;
79826
79827   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79828   {
79829     try {
79830       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79831     } catch (std::out_of_range& e) {
79832       {
79833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79834       };
79835     } catch (std::exception& e) {
79836       {
79837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79838       };
79839     } catch (...) {
79840       {
79841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79842       };
79843     }
79844   }
79845   jresult = result;
79846   return jresult;
79847 }
79848
79849
79850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_MoveFocusForward(void * jarg1) {
79851   unsigned int jresult ;
79852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79853   bool result;
79854
79855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79856   {
79857     try {
79858       result = (bool)(arg1)->MoveFocusForward();
79859     } catch (std::out_of_range& e) {
79860       {
79861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79862       };
79863     } catch (std::exception& e) {
79864       {
79865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79866       };
79867     } catch (...) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79870       };
79871     }
79872   }
79873   jresult = result;
79874   return jresult;
79875 }
79876
79877
79878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79879   unsigned int jresult ;
79880   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79881   bool result;
79882
79883   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79884   {
79885     try {
79886       result = (bool)(arg1)->MoveFocusBackward();
79887     } catch (std::out_of_range& e) {
79888       {
79889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79890       };
79891     } catch (std::exception& e) {
79892       {
79893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79894       };
79895     } catch (...) {
79896       {
79897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79898       };
79899     }
79900   }
79901   jresult = result;
79902   return jresult;
79903 }
79904
79905
79906 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_ClearFocus(void * jarg1) {
79907   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79908
79909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79910   {
79911     try {
79912       (arg1)->ClearFocus();
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79920       };
79921     } catch (...) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79924       };
79925     }
79926   }
79927 }
79928
79929
79930 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_Reset(void * jarg1) {
79931   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79932
79933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79934   {
79935     try {
79936       (arg1)->Reset();
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79944       };
79945     } catch (...) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79948       };
79949     }
79950   }
79951 }
79952
79953
79954 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79956   Dali::Actor arg2 ;
79957   bool arg3 ;
79958   Dali::Actor *argp2 ;
79959
79960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79961   argp2 = (Dali::Actor *)jarg2;
79962   if (!argp2) {
79963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79964     return ;
79965   }
79966   arg2 = *argp2;
79967   arg3 = jarg3 ? true : false;
79968   {
79969     try {
79970       (arg1)->SetFocusGroup(arg2,arg3);
79971     } catch (std::out_of_range& e) {
79972       {
79973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79974       };
79975     } catch (std::exception& e) {
79976       {
79977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79978       };
79979     } catch (...) {
79980       {
79981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79982       };
79983     }
79984   }
79985 }
79986
79987
79988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79989   unsigned int jresult ;
79990   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79991   Dali::Actor arg2 ;
79992   Dali::Actor *argp2 ;
79993   bool result;
79994
79995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79996   argp2 = (Dali::Actor *)jarg2;
79997   if (!argp2) {
79998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79999     return 0;
80000   }
80001   arg2 = *argp2;
80002   {
80003     try {
80004       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (...) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80016       };
80017     }
80018   }
80019   jresult = result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80025   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80026   bool arg2 ;
80027
80028   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80029   arg2 = jarg2 ? true : false;
80030   {
80031     try {
80032       (arg1)->SetGroupMode(arg2);
80033     } catch (std::out_of_range& e) {
80034       {
80035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80036       };
80037     } catch (std::exception& e) {
80038       {
80039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80040       };
80041     } catch (...) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80044       };
80045     }
80046   }
80047 }
80048
80049
80050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetGroupMode(void * jarg1) {
80051   unsigned int jresult ;
80052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80053   bool result;
80054
80055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80056   {
80057     try {
80058       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80059     } catch (std::out_of_range& e) {
80060       {
80061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80062       };
80063     } catch (std::exception& e) {
80064       {
80065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80066       };
80067     } catch (...) {
80068       {
80069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80070       };
80071     }
80072   }
80073   jresult = result;
80074   return jresult;
80075 }
80076
80077
80078 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80080   bool arg2 ;
80081
80082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80083   arg2 = jarg2 ? true : false;
80084   {
80085     try {
80086       (arg1)->SetWrapMode(arg2);
80087     } catch (std::out_of_range& e) {
80088       {
80089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80090       };
80091     } catch (std::exception& e) {
80092       {
80093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80094       };
80095     } catch (...) {
80096       {
80097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80098       };
80099     }
80100   }
80101 }
80102
80103
80104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetWrapMode(void * jarg1) {
80105   unsigned int jresult ;
80106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80107   bool result;
80108
80109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80110   {
80111     try {
80112       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80113     } catch (std::out_of_range& e) {
80114       {
80115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (std::exception& e) {
80118       {
80119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (...) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80124       };
80125     }
80126   }
80127   jresult = result;
80128   return jresult;
80129 }
80130
80131
80132 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80134   Dali::Actor arg2 ;
80135   Dali::Actor *argp2 ;
80136
80137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80138   argp2 = (Dali::Actor *)jarg2;
80139   if (!argp2) {
80140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80141     return ;
80142   }
80143   arg2 = *argp2;
80144   {
80145     try {
80146       (arg1)->SetFocusIndicatorActor(arg2);
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (...) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80158       };
80159     }
80160   }
80161 }
80162
80163
80164 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80165   void * jresult ;
80166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80167   Dali::Actor result;
80168
80169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80170   {
80171     try {
80172       result = (arg1)->GetFocusIndicatorActor();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80184       };
80185     }
80186   }
80187   jresult = new Dali::Actor((const Dali::Actor &)result);
80188   return jresult;
80189 }
80190
80191
80192 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80193   void * jresult ;
80194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80195   Dali::Actor arg2 ;
80196   Dali::Actor *argp2 ;
80197   Dali::Actor result;
80198
80199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80200   argp2 = (Dali::Actor *)jarg2;
80201   if (!argp2) {
80202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80203     return 0;
80204   }
80205   arg2 = *argp2;
80206   {
80207     try {
80208       result = (arg1)->GetFocusGroup(arg2);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80220       };
80221     }
80222   }
80223   jresult = new Dali::Actor((const Dali::Actor &)result);
80224   return jresult;
80225 }
80226
80227
80228 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_GetReadPosition(void * jarg1) {
80229   void * jresult ;
80230   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80231   Dali::Vector2 result;
80232
80233   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80234   {
80235     try {
80236       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80237     } catch (std::out_of_range& e) {
80238       {
80239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80240       };
80241     } catch (std::exception& e) {
80242       {
80243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80244       };
80245     } catch (...) {
80246       {
80247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80248       };
80249     }
80250   }
80251   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80252   return jresult;
80253 }
80254
80255
80256 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80257   void * jresult ;
80258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80259   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80260
80261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80262   {
80263     try {
80264       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80265     } catch (std::out_of_range& e) {
80266       {
80267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80268       };
80269     } catch (std::exception& e) {
80270       {
80271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (...) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80276       };
80277     }
80278   }
80279   jresult = (void *)result;
80280   return jresult;
80281 }
80282
80283
80284 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80285   void * jresult ;
80286   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80287   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80288
80289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80290   {
80291     try {
80292       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80293     } catch (std::out_of_range& e) {
80294       {
80295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80296       };
80297     } catch (std::exception& e) {
80298       {
80299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80304       };
80305     }
80306   }
80307   jresult = (void *)result;
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80313   void * jresult ;
80314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80315   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80316
80317   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80318   {
80319     try {
80320       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80321     } catch (std::out_of_range& e) {
80322       {
80323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80324       };
80325     } catch (std::exception& e) {
80326       {
80327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80328       };
80329     } catch (...) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80332       };
80333     }
80334   }
80335   jresult = (void *)result;
80336   return jresult;
80337 }
80338
80339
80340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80341   void * jresult ;
80342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80343   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80344
80345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80346   {
80347     try {
80348       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80349     } catch (std::out_of_range& e) {
80350       {
80351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80352       };
80353     } catch (std::exception& e) {
80354       {
80355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80360       };
80361     }
80362   }
80363   jresult = (void *)result;
80364   return jresult;
80365 }
80366
80367
80368 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionNextSignal(void * jarg1) {
80369   void * jresult ;
80370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80371   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80372
80373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80374   {
80375     try {
80376       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (...) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80388       };
80389     }
80390   }
80391   jresult = (void *)result;
80392   return jresult;
80393 }
80394
80395
80396 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80397   void * jresult ;
80398   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80399   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80400
80401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80402   {
80403     try {
80404       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80405     } catch (std::out_of_range& e) {
80406       {
80407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80408       };
80409     } catch (std::exception& e) {
80410       {
80411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80412       };
80413     } catch (...) {
80414       {
80415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80416       };
80417     }
80418   }
80419   jresult = (void *)result;
80420   return jresult;
80421 }
80422
80423
80424 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80425   void * jresult ;
80426   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80427   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80428
80429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80430   {
80431     try {
80432       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80433     } catch (std::out_of_range& e) {
80434       {
80435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80436       };
80437     } catch (std::exception& e) {
80438       {
80439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80444       };
80445     }
80446   }
80447   jresult = (void *)result;
80448   return jresult;
80449 }
80450
80451
80452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadSignal(void * jarg1) {
80453   void * jresult ;
80454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80455   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80456
80457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80458   {
80459     try {
80460       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80461     } catch (std::out_of_range& e) {
80462       {
80463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80464       };
80465     } catch (std::exception& e) {
80466       {
80467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80468       };
80469     } catch (...) {
80470       {
80471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80472       };
80473     }
80474   }
80475   jresult = (void *)result;
80476   return jresult;
80477 }
80478
80479
80480 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionOverSignal(void * jarg1) {
80481   void * jresult ;
80482   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80483   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80484
80485   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80486   {
80487     try {
80488       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (...) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80500       };
80501     }
80502   }
80503   jresult = (void *)result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80509   void * jresult ;
80510   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80511   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80512
80513   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80514   {
80515     try {
80516       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (...) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80528       };
80529     }
80530   }
80531   jresult = (void *)result;
80532   return jresult;
80533 }
80534
80535
80536 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80537   void * jresult ;
80538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80539   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80540
80541   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80542   {
80543     try {
80544       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80545     } catch (std::out_of_range& e) {
80546       {
80547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (std::exception& e) {
80550       {
80551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80556       };
80557     }
80558   }
80559   jresult = (void *)result;
80560   return jresult;
80561 }
80562
80563
80564 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionUpSignal(void * jarg1) {
80565   void * jresult ;
80566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80567   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80568
80569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80570   {
80571     try {
80572       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80573     } catch (std::out_of_range& e) {
80574       {
80575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80576       };
80577     } catch (std::exception& e) {
80578       {
80579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (...) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80584       };
80585     }
80586   }
80587   jresult = (void *)result;
80588   return jresult;
80589 }
80590
80591
80592 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionDownSignal(void * jarg1) {
80593   void * jresult ;
80594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80595   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80596
80597   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80598   {
80599     try {
80600       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80601     } catch (std::out_of_range& e) {
80602       {
80603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80604       };
80605     } catch (std::exception& e) {
80606       {
80607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80608       };
80609     } catch (...) {
80610       {
80611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80612       };
80613     }
80614   }
80615   jresult = (void *)result;
80616   return jresult;
80617 }
80618
80619
80620 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80621   void * jresult ;
80622   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80623   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80624
80625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80626   {
80627     try {
80628       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80629     } catch (std::out_of_range& e) {
80630       {
80631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80632       };
80633     } catch (std::exception& e) {
80634       {
80635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80636       };
80637     } catch (...) {
80638       {
80639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80640       };
80641     }
80642   }
80643   jresult = (void *)result;
80644   return jresult;
80645 }
80646
80647
80648 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionBackSignal(void * jarg1) {
80649   void * jresult ;
80650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80651   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80652
80653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80654   {
80655     try {
80656       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80657     } catch (std::out_of_range& e) {
80658       {
80659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80660       };
80661     } catch (std::exception& e) {
80662       {
80663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (...) {
80666       {
80667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80668       };
80669     }
80670   }
80671   jresult = (void *)result;
80672   return jresult;
80673 }
80674
80675
80676 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80677   void * jresult ;
80678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80680
80681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80682   {
80683     try {
80684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80692       };
80693     } catch (...) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80696       };
80697     }
80698   }
80699   jresult = (void *)result;
80700   return jresult;
80701 }
80702
80703
80704 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80705   void * jresult ;
80706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80707   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80708
80709   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80710   {
80711     try {
80712       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80713     } catch (std::out_of_range& e) {
80714       {
80715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80716       };
80717     } catch (std::exception& e) {
80718       {
80719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80724       };
80725     }
80726   }
80727   jresult = (void *)result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80733   void * jresult ;
80734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80735   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80736
80737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80738   {
80739     try {
80740       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80748       };
80749     } catch (...) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80752       };
80753     }
80754   }
80755   jresult = (void *)result;
80756   return jresult;
80757 }
80758
80759
80760 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80761   void * jresult ;
80762   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80763   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80764
80765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80766   {
80767     try {
80768       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80769     } catch (std::out_of_range& e) {
80770       {
80771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80772       };
80773     } catch (std::exception& e) {
80774       {
80775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (...) {
80778       {
80779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80780       };
80781     }
80782   }
80783   jresult = (void *)result;
80784   return jresult;
80785 }
80786
80787
80788 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80789   void * jresult ;
80790   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80791   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80792
80793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80794   {
80795     try {
80796       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80797     } catch (std::out_of_range& e) {
80798       {
80799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (std::exception& e) {
80802       {
80803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80804       };
80805     } catch (...) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80808       };
80809     }
80810   }
80811   jresult = (void *)result;
80812   return jresult;
80813 }
80814
80815
80816 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80817   void * jresult ;
80818   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80819   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80820
80821   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80822   {
80823     try {
80824       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80832       };
80833     } catch (...) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80836       };
80837     }
80838   }
80839   jresult = (void *)result;
80840   return jresult;
80841 }
80842
80843
80844 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80845   void * jresult ;
80846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80847   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80848
80849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80850   {
80851     try {
80852       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80853     } catch (std::out_of_range& e) {
80854       {
80855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (std::exception& e) {
80858       {
80859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867   jresult = (void *)result;
80868   return jresult;
80869 }
80870
80871
80872 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80873   void * jresult ;
80874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80876
80877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80878   {
80879     try {
80880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80888       };
80889     } catch (...) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80892       };
80893     }
80894   }
80895   jresult = (void *)result;
80896   return jresult;
80897 }
80898
80899
80900 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80901   void * jresult ;
80902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80904
80905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80906   {
80907     try {
80908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80909     } catch (std::out_of_range& e) {
80910       {
80911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80912       };
80913     } catch (std::exception& e) {
80914       {
80915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80916       };
80917     } catch (...) {
80918       {
80919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80920       };
80921     }
80922   }
80923   jresult = (void *)result;
80924   return jresult;
80925 }
80926
80927
80928 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80929   void * jresult ;
80930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80931   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80932
80933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80934   {
80935     try {
80936       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80937     } catch (std::out_of_range& e) {
80938       {
80939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80940       };
80941     } catch (std::exception& e) {
80942       {
80943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80948       };
80949     }
80950   }
80951   jresult = (void *)result;
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80957   void * jresult ;
80958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80959   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80960
80961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80962   {
80963     try {
80964       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80965     } catch (std::out_of_range& e) {
80966       {
80967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80968       };
80969     } catch (std::exception& e) {
80970       {
80971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80972       };
80973     } catch (...) {
80974       {
80975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80976       };
80977     }
80978   }
80979   jresult = (void *)result;
80980   return jresult;
80981 }
80982
80983
80984 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80985   void * jresult ;
80986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80988
80989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80990   {
80991     try {
80992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80993     } catch (std::out_of_range& e) {
80994       {
80995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (std::exception& e) {
80998       {
80999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81000       };
81001     } catch (...) {
81002       {
81003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81004       };
81005     }
81006   }
81007   jresult = (void *)result;
81008   return jresult;
81009 }
81010
81011
81012 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81013   void * jresult ;
81014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81015   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81016
81017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81018   {
81019     try {
81020       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81021     } catch (std::out_of_range& e) {
81022       {
81023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81024       };
81025     } catch (std::exception& e) {
81026       {
81027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81028       };
81029     } catch (...) {
81030       {
81031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81032       };
81033     }
81034   }
81035   jresult = (void *)result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81041   void * jresult ;
81042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81043   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81044
81045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81046   {
81047     try {
81048       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81056       };
81057     } catch (...) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81060       };
81061     }
81062   }
81063   jresult = (void *)result;
81064   return jresult;
81065 }
81066
81067
81068 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81069   void * jresult ;
81070   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81071   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81072
81073   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81074   {
81075     try {
81076       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81077     } catch (std::out_of_range& e) {
81078       {
81079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81080       };
81081     } catch (std::exception& e) {
81082       {
81083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81084       };
81085     } catch (...) {
81086       {
81087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81088       };
81089     }
81090   }
81091   jresult = (void *)result;
81092   return jresult;
81093 }
81094
81095
81096 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StyleManager() {
81097   void * jresult ;
81098   Dali::Toolkit::StyleManager *result = 0 ;
81099
81100   {
81101     try {
81102       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81103     } catch (std::out_of_range& e) {
81104       {
81105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81106       };
81107     } catch (std::exception& e) {
81108       {
81109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81110       };
81111     } catch (...) {
81112       {
81113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81114       };
81115     }
81116   }
81117   jresult = (void *)result;
81118   return jresult;
81119 }
81120
81121
81122 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StyleManager(void * jarg1) {
81123   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81124
81125   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81126   {
81127     try {
81128       delete arg1;
81129     } catch (std::out_of_range& e) {
81130       {
81131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81132       };
81133     } catch (std::exception& e) {
81134       {
81135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81136       };
81137     } catch (...) {
81138       {
81139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81140       };
81141     }
81142   }
81143 }
81144
81145
81146 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StyleManager_Get() {
81147   void * jresult ;
81148   Dali::Toolkit::StyleManager result;
81149
81150   {
81151     try {
81152       result = Dali::Toolkit::StyleManager::Get();
81153     } catch (std::out_of_range& e) {
81154       {
81155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (std::exception& e) {
81158       {
81159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81168   return jresult;
81169 }
81170
81171
81172 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81173   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81174   std::string *arg2 = 0 ;
81175
81176   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81177   if (!jarg2) {
81178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81179     return ;
81180   }
81181   std::string arg2_str(jarg2);
81182   arg2 = &arg2_str;
81183   {
81184     try {
81185       (arg1)->ApplyTheme((std::string const &)*arg2);
81186     } catch (std::out_of_range& e) {
81187       {
81188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81189       };
81190     } catch (std::exception& e) {
81191       {
81192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81197       };
81198     }
81199   }
81200
81201   //argout typemap for const std::string&
81202
81203 }
81204
81205
81206 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyDefaultTheme(void * jarg1) {
81207   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81208
81209   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81210   {
81211     try {
81212       (arg1)->ApplyDefaultTheme();
81213     } catch (std::out_of_range& e) {
81214       {
81215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81216       };
81217     } catch (std::exception& e) {
81218       {
81219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81220       };
81221     } catch (...) {
81222       {
81223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81224       };
81225     }
81226   }
81227 }
81228
81229
81230 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81231   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81232   std::string *arg2 = 0 ;
81233   Dali::Property::Value *arg3 = 0 ;
81234
81235   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81236   if (!jarg2) {
81237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81238     return ;
81239   }
81240   std::string arg2_str(jarg2);
81241   arg2 = &arg2_str;
81242   arg3 = (Dali::Property::Value *)jarg3;
81243   if (!arg3) {
81244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81245     return ;
81246   }
81247   {
81248     try {
81249       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81250     } catch (std::out_of_range& e) {
81251       {
81252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81253       };
81254     } catch (std::exception& e) {
81255       {
81256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81257       };
81258     } catch (...) {
81259       {
81260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81261       };
81262     }
81263   }
81264
81265   //argout typemap for const std::string&
81266
81267 }
81268
81269
81270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81271   unsigned int jresult ;
81272   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81273   std::string *arg2 = 0 ;
81274   Dali::Property::Value *arg3 = 0 ;
81275   bool result;
81276
81277   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81278   if (!jarg2) {
81279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81280     return 0;
81281   }
81282   std::string arg2_str(jarg2);
81283   arg2 = &arg2_str;
81284   arg3 = (Dali::Property::Value *)jarg3;
81285   if (!arg3) {
81286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81287     return 0;
81288   }
81289   {
81290     try {
81291       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81292     } catch (std::out_of_range& e) {
81293       {
81294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81295       };
81296     } catch (std::exception& e) {
81297       {
81298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81299       };
81300     } catch (...) {
81301       {
81302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81303       };
81304     }
81305   }
81306   jresult = result;
81307
81308   //argout typemap for const std::string&
81309
81310   return jresult;
81311 }
81312
81313
81314 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81315   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81316   Dali::Toolkit::Control arg2 ;
81317   std::string *arg3 = 0 ;
81318   std::string *arg4 = 0 ;
81319   Dali::Toolkit::Control *argp2 ;
81320
81321   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81322   argp2 = (Dali::Toolkit::Control *)jarg2;
81323   if (!argp2) {
81324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81325     return ;
81326   }
81327   arg2 = *argp2;
81328   if (!jarg3) {
81329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81330     return ;
81331   }
81332   std::string arg3_str(jarg3);
81333   arg3 = &arg3_str;
81334   if (!jarg4) {
81335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81336     return ;
81337   }
81338   std::string arg4_str(jarg4);
81339   arg4 = &arg4_str;
81340   {
81341     try {
81342       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81343     } catch (std::out_of_range& e) {
81344       {
81345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81346       };
81347     } catch (std::exception& e) {
81348       {
81349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81350       };
81351     } catch (...) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81354       };
81355     }
81356   }
81357
81358   //argout typemap for const std::string&
81359
81360
81361   //argout typemap for const std::string&
81362
81363 }
81364
81365
81366 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_StyleManager_StyleChangedSignal(void * jarg1) {
81367   void * jresult ;
81368   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81369   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81370
81371   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81372   {
81373     try {
81374       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81375     } catch (std::out_of_range& e) {
81376       {
81377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81378       };
81379     } catch (std::exception& e) {
81380       {
81381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81382       };
81383     } catch (...) {
81384       {
81385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81386       };
81387     }
81388   }
81389   jresult = (void *)result;
81390   return jresult;
81391 }
81392
81393
81394 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_LOWER_BOUND_get() {
81395   int jresult ;
81396   int result;
81397
81398   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81399   jresult = (int)result;
81400   return jresult;
81401 }
81402
81403
81404 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_UPPER_BOUND_get() {
81405   int jresult ;
81406   int result;
81407
81408   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81409   jresult = (int)result;
81410   return jresult;
81411 }
81412
81413
81414 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_VALUE_get() {
81415   int jresult ;
81416   int result;
81417
81418   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81419   jresult = (int)result;
81420   return jresult;
81421 }
81422
81423
81424 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_TRACK_VISUAL_get() {
81425   int jresult ;
81426   int result;
81427
81428   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81429   jresult = (int)result;
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_HANDLE_VISUAL_get() {
81435   int jresult ;
81436   int result;
81437
81438   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81439   jresult = (int)result;
81440   return jresult;
81441 }
81442
81443
81444 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_PROGRESS_VISUAL_get() {
81445   int jresult ;
81446   int result;
81447
81448   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81449   jresult = (int)result;
81450   return jresult;
81451 }
81452
81453
81454 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_POPUP_VISUAL_get() {
81455   int jresult ;
81456   int result;
81457
81458   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81459   jresult = (int)result;
81460   return jresult;
81461 }
81462
81463
81464 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_POPUP_ARROW_VISUAL_get() {
81465   int jresult ;
81466   int result;
81467
81468   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81469   jresult = (int)result;
81470   return jresult;
81471 }
81472
81473
81474 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_DISABLED_COLOR_get() {
81475   int jresult ;
81476   int result;
81477
81478   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81479   jresult = (int)result;
81480   return jresult;
81481 }
81482
81483
81484 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_VALUE_PRECISION_get() {
81485   int jresult ;
81486   int result;
81487
81488   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81489   jresult = (int)result;
81490   return jresult;
81491 }
81492
81493
81494 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SHOW_POPUP_get() {
81495   int jresult ;
81496   int result;
81497
81498   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81499   jresult = (int)result;
81500   return jresult;
81501 }
81502
81503
81504 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SHOW_VALUE_get() {
81505   int jresult ;
81506   int result;
81507
81508   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81509   jresult = (int)result;
81510   return jresult;
81511 }
81512
81513
81514 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_MARKS_get() {
81515   int jresult ;
81516   int result;
81517
81518   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81519   jresult = (int)result;
81520   return jresult;
81521 }
81522
81523
81524 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_SNAP_TO_MARKS_get() {
81525   int jresult ;
81526   int result;
81527
81528   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81529   jresult = (int)result;
81530   return jresult;
81531 }
81532
81533
81534 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Slider_Property_MARK_TOLERANCE_get() {
81535   int jresult ;
81536   int result;
81537
81538   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81539   jresult = (int)result;
81540   return jresult;
81541 }
81542
81543
81544 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider_Property() {
81545   void * jresult ;
81546   Dali::Toolkit::Slider::Property *result = 0 ;
81547
81548   {
81549     try {
81550       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81551     } catch (std::out_of_range& e) {
81552       {
81553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81554       };
81555     } catch (std::exception& e) {
81556       {
81557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81558       };
81559     } catch (...) {
81560       {
81561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81562       };
81563     }
81564   }
81565   jresult = (void *)result;
81566   return jresult;
81567 }
81568
81569
81570 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Slider_Property(void * jarg1) {
81571   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81572
81573   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81574   {
81575     try {
81576       delete arg1;
81577     } catch (std::out_of_range& e) {
81578       {
81579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81580       };
81581     } catch (std::exception& e) {
81582       {
81583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81584       };
81585     } catch (...) {
81586       {
81587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81588       };
81589     }
81590   }
81591 }
81592
81593
81594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_New() {
81595   void * jresult ;
81596   Dali::Toolkit::Slider result;
81597
81598   {
81599     try {
81600       result = Dali::Toolkit::Slider::New();
81601     } catch (std::out_of_range& e) {
81602       {
81603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (std::exception& e) {
81606       {
81607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81612       };
81613     }
81614   }
81615   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider__SWIG_0() {
81621   void * jresult ;
81622   Dali::Toolkit::Slider *result = 0 ;
81623
81624   {
81625     try {
81626       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81627     } catch (std::out_of_range& e) {
81628       {
81629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81630       };
81631     } catch (std::exception& e) {
81632       {
81633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81634       };
81635     } catch (...) {
81636       {
81637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81638       };
81639     }
81640   }
81641   jresult = (void *)result;
81642   return jresult;
81643 }
81644
81645
81646 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Slider__SWIG_1(void * jarg1) {
81647   void * jresult ;
81648   Dali::Toolkit::Slider *arg1 = 0 ;
81649   Dali::Toolkit::Slider *result = 0 ;
81650
81651   arg1 = (Dali::Toolkit::Slider *)jarg1;
81652   if (!arg1) {
81653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81654     return 0;
81655   }
81656   {
81657     try {
81658       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81659     } catch (std::out_of_range& e) {
81660       {
81661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81662       };
81663     } catch (std::exception& e) {
81664       {
81665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81666       };
81667     } catch (...) {
81668       {
81669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81670       };
81671     }
81672   }
81673   jresult = (void *)result;
81674   return jresult;
81675 }
81676
81677
81678 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_Assign(void * jarg1, void * jarg2) {
81679   void * jresult ;
81680   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81681   Dali::Toolkit::Slider *arg2 = 0 ;
81682   Dali::Toolkit::Slider *result = 0 ;
81683
81684   arg1 = (Dali::Toolkit::Slider *)jarg1;
81685   arg2 = (Dali::Toolkit::Slider *)jarg2;
81686   if (!arg2) {
81687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81688     return 0;
81689   }
81690   {
81691     try {
81692       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81693     } catch (std::out_of_range& e) {
81694       {
81695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81696       };
81697     } catch (std::exception& e) {
81698       {
81699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (...) {
81702       {
81703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81704       };
81705     }
81706   }
81707   jresult = (void *)result;
81708   return jresult;
81709 }
81710
81711
81712 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Slider(void * jarg1) {
81713   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81714
81715   arg1 = (Dali::Toolkit::Slider *)jarg1;
81716   {
81717     try {
81718       delete arg1;
81719     } catch (std::out_of_range& e) {
81720       {
81721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81722       };
81723     } catch (std::exception& e) {
81724       {
81725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (...) {
81728       {
81729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81730       };
81731     }
81732   }
81733 }
81734
81735
81736 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_DownCast(void * jarg1) {
81737   void * jresult ;
81738   Dali::BaseHandle arg1 ;
81739   Dali::BaseHandle *argp1 ;
81740   Dali::Toolkit::Slider result;
81741
81742   argp1 = (Dali::BaseHandle *)jarg1;
81743   if (!argp1) {
81744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81745     return 0;
81746   }
81747   arg1 = *argp1;
81748   {
81749     try {
81750       result = Dali::Toolkit::Slider::DownCast(arg1);
81751     } catch (std::out_of_range& e) {
81752       {
81753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81754       };
81755     } catch (std::exception& e) {
81756       {
81757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81758       };
81759     } catch (...) {
81760       {
81761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81762       };
81763     }
81764   }
81765   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81766   return jresult;
81767 }
81768
81769
81770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_ValueChangedSignal(void * jarg1) {
81771   void * jresult ;
81772   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81773   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81774
81775   arg1 = (Dali::Toolkit::Slider *)jarg1;
81776   {
81777     try {
81778       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81779     } catch (std::out_of_range& e) {
81780       {
81781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81782       };
81783     } catch (std::exception& e) {
81784       {
81785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81786       };
81787     } catch (...) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81790       };
81791     }
81792   }
81793   jresult = (void *)result;
81794   return jresult;
81795 }
81796
81797
81798 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_SlidingFinishedSignal(void * jarg1) {
81799   void * jresult ;
81800   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81801   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81802
81803   arg1 = (Dali::Toolkit::Slider *)jarg1;
81804   {
81805     try {
81806       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81807     } catch (std::out_of_range& e) {
81808       {
81809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81810       };
81811     } catch (std::exception& e) {
81812       {
81813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81814       };
81815     } catch (...) {
81816       {
81817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81818       };
81819     }
81820   }
81821   jresult = (void *)result;
81822   return jresult;
81823 }
81824
81825
81826 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Slider_MarkReachedSignal(void * jarg1) {
81827   void * jresult ;
81828   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81829   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81830
81831   arg1 = (Dali::Toolkit::Slider *)jarg1;
81832   {
81833     try {
81834       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81835     } catch (std::out_of_range& e) {
81836       {
81837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (std::exception& e) {
81840       {
81841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81842       };
81843     } catch (...) {
81844       {
81845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81846       };
81847     }
81848   }
81849   jresult = (void *)result;
81850   return jresult;
81851 }
81852
81853
81854 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_VIDEO_get() {
81855   int jresult ;
81856   int result;
81857
81858   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81859   jresult = (int)result;
81860   return jresult;
81861 }
81862
81863
81864 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_LOOPING_get() {
81865   int jresult ;
81866   int result;
81867
81868   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81869   jresult = (int)result;
81870   return jresult;
81871 }
81872
81873
81874 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_MUTED_get() {
81875   int jresult ;
81876   int result;
81877
81878   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81879   jresult = (int)result;
81880   return jresult;
81881 }
81882
81883
81884 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_VideoView_Property_VOLUME_get() {
81885   int jresult ;
81886   int result;
81887
81888   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81889   jresult = (int)result;
81890   return jresult;
81891 }
81892
81893
81894 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView_Property() {
81895   void * jresult ;
81896   Dali::Toolkit::VideoView::Property *result = 0 ;
81897
81898   {
81899     try {
81900       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81901     } catch (std::out_of_range& e) {
81902       {
81903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81904       };
81905     } catch (std::exception& e) {
81906       {
81907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81908       };
81909     } catch (...) {
81910       {
81911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81912       };
81913     }
81914   }
81915   jresult = (void *)result;
81916   return jresult;
81917 }
81918
81919
81920 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoView_Property(void * jarg1) {
81921   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81922
81923   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81924   {
81925     try {
81926       delete arg1;
81927     } catch (std::out_of_range& e) {
81928       {
81929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81930       };
81931     } catch (std::exception& e) {
81932       {
81933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81938       };
81939     }
81940   }
81941 }
81942
81943
81944 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_New__SWIG_0() {
81945   void * jresult ;
81946   Dali::Toolkit::VideoView result;
81947
81948   {
81949     try {
81950       result = Dali::Toolkit::VideoView::New();
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (...) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81962       };
81963     }
81964   }
81965   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81966   return jresult;
81967 }
81968
81969
81970 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_New__SWIG_1(char * jarg1) {
81971   void * jresult ;
81972   std::string *arg1 = 0 ;
81973   Dali::Toolkit::VideoView result;
81974
81975   if (!jarg1) {
81976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81977     return 0;
81978   }
81979   std::string arg1_str(jarg1);
81980   arg1 = &arg1_str;
81981   {
81982     try {
81983       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81984     } catch (std::out_of_range& e) {
81985       {
81986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81987       };
81988     } catch (std::exception& e) {
81989       {
81990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81991       };
81992     } catch (...) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81995       };
81996     }
81997   }
81998   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81999
82000   //argout typemap for const std::string&
82001
82002   return jresult;
82003 }
82004
82005
82006 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView__SWIG_0() {
82007   void * jresult ;
82008   Dali::Toolkit::VideoView *result = 0 ;
82009
82010   {
82011     try {
82012       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82013     } catch (std::out_of_range& e) {
82014       {
82015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82016       };
82017     } catch (std::exception& e) {
82018       {
82019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82020       };
82021     } catch (...) {
82022       {
82023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82024       };
82025     }
82026   }
82027   jresult = (void *)result;
82028   return jresult;
82029 }
82030
82031
82032 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoView(void * jarg1) {
82033   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82034
82035   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82036   {
82037     try {
82038       delete arg1;
82039     } catch (std::out_of_range& e) {
82040       {
82041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (std::exception& e) {
82044       {
82045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82046       };
82047     } catch (...) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82050       };
82051     }
82052   }
82053 }
82054
82055
82056 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoView__SWIG_1(void * jarg1) {
82057   void * jresult ;
82058   Dali::Toolkit::VideoView *arg1 = 0 ;
82059   Dali::Toolkit::VideoView *result = 0 ;
82060
82061   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82062   if (!arg1) {
82063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82064     return 0;
82065   }
82066   {
82067     try {
82068       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (...) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82080       };
82081     }
82082   }
82083   jresult = (void *)result;
82084   return jresult;
82085 }
82086
82087
82088 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_Assign(void * jarg1, void * jarg2) {
82089   void * jresult ;
82090   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82091   Dali::Toolkit::VideoView *arg2 = 0 ;
82092   Dali::Toolkit::VideoView *result = 0 ;
82093
82094   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82095   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82096   if (!arg2) {
82097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82098     return 0;
82099   }
82100   {
82101     try {
82102       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82103     } catch (std::out_of_range& e) {
82104       {
82105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82106       };
82107     } catch (std::exception& e) {
82108       {
82109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82110       };
82111     } catch (...) {
82112       {
82113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82114       };
82115     }
82116   }
82117   jresult = (void *)result;
82118   return jresult;
82119 }
82120
82121
82122 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_DownCast(void * jarg1) {
82123   void * jresult ;
82124   Dali::BaseHandle arg1 ;
82125   Dali::BaseHandle *argp1 ;
82126   Dali::Toolkit::VideoView result;
82127
82128   argp1 = (Dali::BaseHandle *)jarg1;
82129   if (!argp1) {
82130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82131     return 0;
82132   }
82133   arg1 = *argp1;
82134   {
82135     try {
82136       result = Dali::Toolkit::VideoView::DownCast(arg1);
82137     } catch (std::out_of_range& e) {
82138       {
82139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82140       };
82141     } catch (std::exception& e) {
82142       {
82143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82144       };
82145     } catch (...) {
82146       {
82147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82148       };
82149     }
82150   }
82151   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82152   return jresult;
82153 }
82154
82155
82156 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Play(void * jarg1) {
82157   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82158
82159   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82160   {
82161     try {
82162       (arg1)->Play();
82163     } catch (std::out_of_range& e) {
82164       {
82165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82166       };
82167     } catch (std::exception& e) {
82168       {
82169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82174       };
82175     }
82176   }
82177 }
82178
82179
82180 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Pause(void * jarg1) {
82181   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82182
82183   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82184   {
82185     try {
82186       (arg1)->Pause();
82187     } catch (std::out_of_range& e) {
82188       {
82189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (std::exception& e) {
82192       {
82193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82198       };
82199     }
82200   }
82201 }
82202
82203
82204 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Stop(void * jarg1) {
82205   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82206
82207   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82208   {
82209     try {
82210       (arg1)->Stop();
82211     } catch (std::out_of_range& e) {
82212       {
82213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82214       };
82215     } catch (std::exception& e) {
82216       {
82217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82218       };
82219     } catch (...) {
82220       {
82221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82222       };
82223     }
82224   }
82225 }
82226
82227
82228 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Forward(void * jarg1, int jarg2) {
82229   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82230   int arg2 ;
82231
82232   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82233   arg2 = (int)jarg2;
82234   {
82235     try {
82236       (arg1)->Forward(arg2);
82237     } catch (std::out_of_range& e) {
82238       {
82239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82240       };
82241     } catch (std::exception& e) {
82242       {
82243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82244       };
82245     } catch (...) {
82246       {
82247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82248       };
82249     }
82250   }
82251 }
82252
82253
82254 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoView_Backward(void * jarg1, int jarg2) {
82255   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82256   int arg2 ;
82257
82258   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82259   arg2 = (int)jarg2;
82260   {
82261     try {
82262       (arg1)->Backward(arg2);
82263     } catch (std::out_of_range& e) {
82264       {
82265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82266       };
82267     } catch (std::exception& e) {
82268       {
82269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82270       };
82271     } catch (...) {
82272       {
82273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82274       };
82275     }
82276   }
82277 }
82278
82279
82280 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VideoView_FinishedSignal(void * jarg1) {
82281   void * jresult ;
82282   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82283   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82284
82285   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82286   {
82287     try {
82288       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82289     } catch (std::out_of_range& e) {
82290       {
82291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82292       };
82293     } catch (std::exception& e) {
82294       {
82295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82296       };
82297     } catch (...) {
82298       {
82299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82300       };
82301     }
82302   }
82303   jresult = (void *)result;
82304   return jresult;
82305 }
82306
82307
82308 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TITLE_get() {
82309   int jresult ;
82310   int result;
82311
82312   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82313   jresult = (int)result;
82314   return jresult;
82315 }
82316
82317
82318 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_CONTENT_get() {
82319   int jresult ;
82320   int result;
82321
82322   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82323   jresult = (int)result;
82324   return jresult;
82325 }
82326
82327
82328 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_FOOTER_get() {
82329   int jresult ;
82330   int result;
82331
82332   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82333   jresult = (int)result;
82334   return jresult;
82335 }
82336
82337
82338 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_DISPLAY_STATE_get() {
82339   int jresult ;
82340   int result;
82341
82342   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82343   jresult = (int)result;
82344   return jresult;
82345 }
82346
82347
82348 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TOUCH_TRANSPARENT_get() {
82349   int jresult ;
82350   int result;
82351
82352   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82353   jresult = (int)result;
82354   return jresult;
82355 }
82356
82357
82358 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_VISIBILITY_get() {
82359   int jresult ;
82360   int result;
82361
82362   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82363   jresult = (int)result;
82364   return jresult;
82365 }
82366
82367
82368 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_POSITION_get() {
82369   int jresult ;
82370   int result;
82371
82372   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82373   jresult = (int)result;
82374   return jresult;
82375 }
82376
82377
82378 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_CONTEXTUAL_MODE_get() {
82379   int jresult ;
82380   int result;
82381
82382   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82383   jresult = (int)result;
82384   return jresult;
82385 }
82386
82387
82388 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ANIMATION_DURATION_get() {
82389   int jresult ;
82390   int result;
82391
82392   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82393   jresult = (int)result;
82394   return jresult;
82395 }
82396
82397
82398 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ANIMATION_MODE_get() {
82399   int jresult ;
82400   int result;
82401
82402   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82403   jresult = (int)result;
82404   return jresult;
82405 }
82406
82407
82408 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_ENTRY_ANIMATION_get() {
82409   int jresult ;
82410   int result;
82411
82412   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82413   jresult = (int)result;
82414   return jresult;
82415 }
82416
82417
82418 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_EXIT_ANIMATION_get() {
82419   int jresult ;
82420   int result;
82421
82422   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82423   jresult = (int)result;
82424   return jresult;
82425 }
82426
82427
82428 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_AUTO_HIDE_DELAY_get() {
82429   int jresult ;
82430   int result;
82431
82432   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82433   jresult = (int)result;
82434   return jresult;
82435 }
82436
82437
82438 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_BACKING_ENABLED_get() {
82439   int jresult ;
82440   int result;
82441
82442   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82443   jresult = (int)result;
82444   return jresult;
82445 }
82446
82447
82448 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_BACKING_COLOR_get() {
82449   int jresult ;
82450   int result;
82451
82452   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82453   jresult = (int)result;
82454   return jresult;
82455 }
82456
82457
82458 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82459   int jresult ;
82460   int result;
82461
82462   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82463   jresult = (int)result;
82464   return jresult;
82465 }
82466
82467
82468 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82469   int jresult ;
82470   int result;
82471
82472   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82473   jresult = (int)result;
82474   return jresult;
82475 }
82476
82477
82478 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_UP_IMAGE_get() {
82479   int jresult ;
82480   int result;
82481
82482   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82483   jresult = (int)result;
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_DOWN_IMAGE_get() {
82489   int jresult ;
82490   int result;
82491
82492   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82493   jresult = (int)result;
82494   return jresult;
82495 }
82496
82497
82498 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_LEFT_IMAGE_get() {
82499   int jresult ;
82500   int result;
82501
82502   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82503   jresult = (int)result;
82504   return jresult;
82505 }
82506
82507
82508 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82509   int jresult ;
82510   int result;
82511
82512   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82513   jresult = (int)result;
82514   return jresult;
82515 }
82516
82517
82518 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup_Property() {
82519   void * jresult ;
82520   Dali::Toolkit::Popup::Property *result = 0 ;
82521
82522   {
82523     try {
82524       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82525     } catch (std::out_of_range& e) {
82526       {
82527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82528       };
82529     } catch (std::exception& e) {
82530       {
82531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82532       };
82533     } catch (...) {
82534       {
82535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82536       };
82537     }
82538   }
82539   jresult = (void *)result;
82540   return jresult;
82541 }
82542
82543
82544 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Popup_Property(void * jarg1) {
82545   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82546
82547   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82548   {
82549     try {
82550       delete arg1;
82551     } catch (std::out_of_range& e) {
82552       {
82553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82554       };
82555     } catch (std::exception& e) {
82556       {
82557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82558       };
82559     } catch (...) {
82560       {
82561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82562       };
82563     }
82564   }
82565 }
82566
82567
82568 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup__SWIG_0() {
82569   void * jresult ;
82570   Dali::Toolkit::Popup *result = 0 ;
82571
82572   {
82573     try {
82574       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (...) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82586       };
82587     }
82588   }
82589   jresult = (void *)result;
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_New() {
82595   void * jresult ;
82596   Dali::Toolkit::Popup result;
82597
82598   {
82599     try {
82600       result = Dali::Toolkit::Popup::New();
82601     } catch (std::out_of_range& e) {
82602       {
82603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82604       };
82605     } catch (std::exception& e) {
82606       {
82607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82608       };
82609     } catch (...) {
82610       {
82611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82612       };
82613     }
82614   }
82615   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82616   return jresult;
82617 }
82618
82619
82620 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Popup(void * jarg1) {
82621   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82622
82623   arg1 = (Dali::Toolkit::Popup *)jarg1;
82624   {
82625     try {
82626       delete arg1;
82627     } catch (std::out_of_range& e) {
82628       {
82629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82630       };
82631     } catch (std::exception& e) {
82632       {
82633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82634       };
82635     } catch (...) {
82636       {
82637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82638       };
82639     }
82640   }
82641 }
82642
82643
82644 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Popup__SWIG_1(void * jarg1) {
82645   void * jresult ;
82646   Dali::Toolkit::Popup *arg1 = 0 ;
82647   Dali::Toolkit::Popup *result = 0 ;
82648
82649   arg1 = (Dali::Toolkit::Popup *)jarg1;
82650   if (!arg1) {
82651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82652     return 0;
82653   }
82654   {
82655     try {
82656       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82657     } catch (std::out_of_range& e) {
82658       {
82659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82660       };
82661     } catch (std::exception& e) {
82662       {
82663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82664       };
82665     } catch (...) {
82666       {
82667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82668       };
82669     }
82670   }
82671   jresult = (void *)result;
82672   return jresult;
82673 }
82674
82675
82676 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_Assign(void * jarg1, void * jarg2) {
82677   void * jresult ;
82678   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82679   Dali::Toolkit::Popup *arg2 = 0 ;
82680   Dali::Toolkit::Popup *result = 0 ;
82681
82682   arg1 = (Dali::Toolkit::Popup *)jarg1;
82683   arg2 = (Dali::Toolkit::Popup *)jarg2;
82684   if (!arg2) {
82685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82686     return 0;
82687   }
82688   {
82689     try {
82690       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82691     } catch (std::out_of_range& e) {
82692       {
82693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (std::exception& e) {
82696       {
82697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82698       };
82699     } catch (...) {
82700       {
82701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82702       };
82703     }
82704   }
82705   jresult = (void *)result;
82706   return jresult;
82707 }
82708
82709
82710 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_DownCast(void * jarg1) {
82711   void * jresult ;
82712   Dali::BaseHandle arg1 ;
82713   Dali::BaseHandle *argp1 ;
82714   Dali::Toolkit::Popup result;
82715
82716   argp1 = (Dali::BaseHandle *)jarg1;
82717   if (!argp1) {
82718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82719     return 0;
82720   }
82721   arg1 = *argp1;
82722   {
82723     try {
82724       result = Dali::Toolkit::Popup::DownCast(arg1);
82725     } catch (std::out_of_range& e) {
82726       {
82727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82728       };
82729     } catch (std::exception& e) {
82730       {
82731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82732       };
82733     } catch (...) {
82734       {
82735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82736       };
82737     }
82738   }
82739   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82740   return jresult;
82741 }
82742
82743
82744 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetTitle(void * jarg1, void * jarg2) {
82745   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82746   Dali::Actor arg2 ;
82747   Dali::Actor *argp2 ;
82748
82749   arg1 = (Dali::Toolkit::Popup *)jarg1;
82750   argp2 = (Dali::Actor *)jarg2;
82751   if (!argp2) {
82752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82753     return ;
82754   }
82755   arg2 = *argp2;
82756   {
82757     try {
82758       (arg1)->SetTitle(arg2);
82759     } catch (std::out_of_range& e) {
82760       {
82761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82762       };
82763     } catch (std::exception& e) {
82764       {
82765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82766       };
82767     } catch (...) {
82768       {
82769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82770       };
82771     }
82772   }
82773 }
82774
82775
82776 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetTitle(void * jarg1) {
82777   void * jresult ;
82778   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82779   Dali::Actor result;
82780
82781   arg1 = (Dali::Toolkit::Popup *)jarg1;
82782   {
82783     try {
82784       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82785     } catch (std::out_of_range& e) {
82786       {
82787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82788       };
82789     } catch (std::exception& e) {
82790       {
82791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82792       };
82793     } catch (...) {
82794       {
82795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82796       };
82797     }
82798   }
82799   jresult = new Dali::Actor((const Dali::Actor &)result);
82800   return jresult;
82801 }
82802
82803
82804 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetContent(void * jarg1, void * jarg2) {
82805   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82806   Dali::Actor arg2 ;
82807   Dali::Actor *argp2 ;
82808
82809   arg1 = (Dali::Toolkit::Popup *)jarg1;
82810   argp2 = (Dali::Actor *)jarg2;
82811   if (!argp2) {
82812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82813     return ;
82814   }
82815   arg2 = *argp2;
82816   {
82817     try {
82818       (arg1)->SetContent(arg2);
82819     } catch (std::out_of_range& e) {
82820       {
82821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82822       };
82823     } catch (std::exception& e) {
82824       {
82825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82826       };
82827     } catch (...) {
82828       {
82829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82830       };
82831     }
82832   }
82833 }
82834
82835
82836 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetContent(void * jarg1) {
82837   void * jresult ;
82838   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82839   Dali::Actor result;
82840
82841   arg1 = (Dali::Toolkit::Popup *)jarg1;
82842   {
82843     try {
82844       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82845     } catch (std::out_of_range& e) {
82846       {
82847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82848       };
82849     } catch (std::exception& e) {
82850       {
82851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (...) {
82854       {
82855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82856       };
82857     }
82858   }
82859   jresult = new Dali::Actor((const Dali::Actor &)result);
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetFooter(void * jarg1, void * jarg2) {
82865   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82866   Dali::Actor arg2 ;
82867   Dali::Actor *argp2 ;
82868
82869   arg1 = (Dali::Toolkit::Popup *)jarg1;
82870   argp2 = (Dali::Actor *)jarg2;
82871   if (!argp2) {
82872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82873     return ;
82874   }
82875   arg2 = *argp2;
82876   {
82877     try {
82878       (arg1)->SetFooter(arg2);
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82886       };
82887     } catch (...) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82890       };
82891     }
82892   }
82893 }
82894
82895
82896 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_GetFooter(void * jarg1) {
82897   void * jresult ;
82898   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82899   Dali::Actor result;
82900
82901   arg1 = (Dali::Toolkit::Popup *)jarg1;
82902   {
82903     try {
82904       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82905     } catch (std::out_of_range& e) {
82906       {
82907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (std::exception& e) {
82910       {
82911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82916       };
82917     }
82918   }
82919   jresult = new Dali::Actor((const Dali::Actor &)result);
82920   return jresult;
82921 }
82922
82923
82924 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Popup_SetDisplayState(void * jarg1, int jarg2) {
82925   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82926   Dali::Toolkit::Popup::DisplayState arg2 ;
82927
82928   arg1 = (Dali::Toolkit::Popup *)jarg1;
82929   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82930   {
82931     try {
82932       (arg1)->SetDisplayState(arg2);
82933     } catch (std::out_of_range& e) {
82934       {
82935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82936       };
82937     } catch (std::exception& e) {
82938       {
82939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82940       };
82941     } catch (...) {
82942       {
82943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82944       };
82945     }
82946   }
82947 }
82948
82949
82950 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_Popup_GetDisplayState(void * jarg1) {
82951   int jresult ;
82952   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82953   Dali::Toolkit::Popup::DisplayState result;
82954
82955   arg1 = (Dali::Toolkit::Popup *)jarg1;
82956   {
82957     try {
82958       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82959     } catch (std::out_of_range& e) {
82960       {
82961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82962       };
82963     } catch (std::exception& e) {
82964       {
82965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (...) {
82968       {
82969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82970       };
82971     }
82972   }
82973   jresult = (int)result;
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_OutsideTouchedSignal(void * jarg1) {
82979   void * jresult ;
82980   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82981   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82982
82983   arg1 = (Dali::Toolkit::Popup *)jarg1;
82984   {
82985     try {
82986       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82994       };
82995     } catch (...) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82998       };
82999     }
83000   }
83001   jresult = (void *)result;
83002   return jresult;
83003 }
83004
83005
83006 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_ShowingSignal(void * jarg1) {
83007   void * jresult ;
83008   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83009   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83010
83011   arg1 = (Dali::Toolkit::Popup *)jarg1;
83012   {
83013     try {
83014       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83015     } catch (std::out_of_range& e) {
83016       {
83017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83018       };
83019     } catch (std::exception& e) {
83020       {
83021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83022       };
83023     } catch (...) {
83024       {
83025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83026       };
83027     }
83028   }
83029   jresult = (void *)result;
83030   return jresult;
83031 }
83032
83033
83034 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_ShownSignal(void * jarg1) {
83035   void * jresult ;
83036   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83037   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83038
83039   arg1 = (Dali::Toolkit::Popup *)jarg1;
83040   {
83041     try {
83042       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83043     } catch (std::out_of_range& e) {
83044       {
83045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83046       };
83047     } catch (std::exception& e) {
83048       {
83049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83050       };
83051     } catch (...) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83054       };
83055     }
83056   }
83057   jresult = (void *)result;
83058   return jresult;
83059 }
83060
83061
83062 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_HidingSignal(void * jarg1) {
83063   void * jresult ;
83064   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83065   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83066
83067   arg1 = (Dali::Toolkit::Popup *)jarg1;
83068   {
83069     try {
83070       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83071     } catch (std::out_of_range& e) {
83072       {
83073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83074       };
83075     } catch (std::exception& e) {
83076       {
83077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83078       };
83079     } catch (...) {
83080       {
83081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83082       };
83083     }
83084   }
83085   jresult = (void *)result;
83086   return jresult;
83087 }
83088
83089
83090 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Popup_HiddenSignal(void * jarg1) {
83091   void * jresult ;
83092   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83093   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83094
83095   arg1 = (Dali::Toolkit::Popup *)jarg1;
83096   {
83097     try {
83098       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83099     } catch (std::out_of_range& e) {
83100       {
83101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83102       };
83103     } catch (std::exception& e) {
83104       {
83105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83106       };
83107     } catch (...) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83110       };
83111     }
83112   }
83113   jresult = (void *)result;
83114   return jresult;
83115 }
83116
83117
83118 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_PROGRESS_VALUE_get() {
83119   int jresult ;
83120   int result;
83121
83122   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83123   jresult = (int)result;
83124   return jresult;
83125 }
83126
83127
83128 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_TRACK_VISUAL_get() {
83129   int jresult ;
83130   int result;
83131
83132   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83133   jresult = (int)result;
83134   return jresult;
83135 }
83136
83137
83138 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ProgressBar_Property_PROGRESS_VISUAL_get() {
83139   int jresult ;
83140   int result;
83141
83142   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83143   jresult = (int)result;
83144   return jresult;
83145 }
83146
83147
83148 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar_Property() {
83149   void * jresult ;
83150   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83151
83152   {
83153     try {
83154       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83155     } catch (std::out_of_range& e) {
83156       {
83157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83158       };
83159     } catch (std::exception& e) {
83160       {
83161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83162       };
83163     } catch (...) {
83164       {
83165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83166       };
83167     }
83168   }
83169   jresult = (void *)result;
83170   return jresult;
83171 }
83172
83173
83174 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ProgressBar_Property(void * jarg1) {
83175   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83176
83177   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83178   {
83179     try {
83180       delete arg1;
83181     } catch (std::out_of_range& e) {
83182       {
83183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83184       };
83185     } catch (std::exception& e) {
83186       {
83187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83188       };
83189     } catch (...) {
83190       {
83191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83192       };
83193     }
83194   }
83195 }
83196
83197
83198 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_New() {
83199   void * jresult ;
83200   Dali::Toolkit::ProgressBar result;
83201
83202   {
83203     try {
83204       result = Dali::Toolkit::ProgressBar::New();
83205     } catch (std::out_of_range& e) {
83206       {
83207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83208       };
83209     } catch (std::exception& e) {
83210       {
83211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83212       };
83213     } catch (...) {
83214       {
83215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83216       };
83217     }
83218   }
83219   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83220   return jresult;
83221 }
83222
83223
83224 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar__SWIG_0() {
83225   void * jresult ;
83226   Dali::Toolkit::ProgressBar *result = 0 ;
83227
83228   {
83229     try {
83230       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83231     } catch (std::out_of_range& e) {
83232       {
83233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83234       };
83235     } catch (std::exception& e) {
83236       {
83237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83238       };
83239     } catch (...) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83242       };
83243     }
83244   }
83245   jresult = (void *)result;
83246   return jresult;
83247 }
83248
83249
83250 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ProgressBar__SWIG_1(void * jarg1) {
83251   void * jresult ;
83252   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83253   Dali::Toolkit::ProgressBar *result = 0 ;
83254
83255   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83256   if (!arg1) {
83257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83258     return 0;
83259   }
83260   {
83261     try {
83262       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83263     } catch (std::out_of_range& e) {
83264       {
83265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83266       };
83267     } catch (std::exception& e) {
83268       {
83269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (...) {
83272       {
83273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83274       };
83275     }
83276   }
83277   jresult = (void *)result;
83278   return jresult;
83279 }
83280
83281
83282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_Assign(void * jarg1, void * jarg2) {
83283   void * jresult ;
83284   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83285   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83286   Dali::Toolkit::ProgressBar *result = 0 ;
83287
83288   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83289   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83290   if (!arg2) {
83291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83292     return 0;
83293   }
83294   {
83295     try {
83296       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83297     } catch (std::out_of_range& e) {
83298       {
83299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83300       };
83301     } catch (std::exception& e) {
83302       {
83303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83304       };
83305     } catch (...) {
83306       {
83307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83308       };
83309     }
83310   }
83311   jresult = (void *)result;
83312   return jresult;
83313 }
83314
83315
83316 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ProgressBar(void * jarg1) {
83317   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83318
83319   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83320   {
83321     try {
83322       delete arg1;
83323     } catch (std::out_of_range& e) {
83324       {
83325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83326       };
83327     } catch (std::exception& e) {
83328       {
83329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83330       };
83331     } catch (...) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83334       };
83335     }
83336   }
83337 }
83338
83339
83340 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_DownCast(void * jarg1) {
83341   void * jresult ;
83342   Dali::BaseHandle arg1 ;
83343   Dali::BaseHandle *argp1 ;
83344   Dali::Toolkit::ProgressBar result;
83345
83346   argp1 = (Dali::BaseHandle *)jarg1;
83347   if (!argp1) {
83348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83349     return 0;
83350   }
83351   arg1 = *argp1;
83352   {
83353     try {
83354       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83355     } catch (std::out_of_range& e) {
83356       {
83357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83358       };
83359     } catch (std::exception& e) {
83360       {
83361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83362       };
83363     } catch (...) {
83364       {
83365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83366       };
83367     }
83368   }
83369   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83370   return jresult;
83371 }
83372
83373
83374 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ProgressBar_ValueChangedSignal(void * jarg1) {
83375   void * jresult ;
83376   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83377   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83378
83379   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83380   {
83381     try {
83382       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83383     } catch (std::out_of_range& e) {
83384       {
83385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (std::exception& e) {
83388       {
83389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83394       };
83395     }
83396   }
83397   jresult = (void *)result;
83398   return jresult;
83399 }
83400
83401
83402 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurView__SWIG_0() {
83403   void * jresult ;
83404   Dali::Toolkit::GaussianBlurView *result = 0 ;
83405
83406   {
83407     try {
83408       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83409     } catch (std::out_of_range& e) {
83410       {
83411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83412       };
83413     } catch (std::exception& e) {
83414       {
83415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (...) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83420       };
83421     }
83422   }
83423   jresult = (void *)result;
83424   return jresult;
83425 }
83426
83427
83428 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurView__SWIG_1(void * jarg1) {
83429   void * jresult ;
83430   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83431   Dali::Toolkit::GaussianBlurView *result = 0 ;
83432
83433   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83434   if (!arg1) {
83435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83436     return 0;
83437   }
83438   {
83439     try {
83440       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (...) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83452       };
83453     }
83454   }
83455   jresult = (void *)result;
83456   return jresult;
83457 }
83458
83459
83460 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83461   void * jresult ;
83462   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83463   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83464   Dali::Toolkit::GaussianBlurView *result = 0 ;
83465
83466   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83467   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83468   if (!arg2) {
83469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83470     return 0;
83471   }
83472   {
83473     try {
83474       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (...) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83486       };
83487     }
83488   }
83489   jresult = (void *)result;
83490   return jresult;
83491 }
83492
83493
83494 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GaussianBlurView(void * jarg1) {
83495   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83496
83497   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83498   {
83499     try {
83500       delete arg1;
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83508       };
83509     } catch (...) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83512       };
83513     }
83514   }
83515 }
83516
83517
83518 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_DownCast(void * jarg1) {
83519   void * jresult ;
83520   Dali::BaseHandle arg1 ;
83521   Dali::BaseHandle *argp1 ;
83522   Dali::Toolkit::GaussianBlurView result;
83523
83524   argp1 = (Dali::BaseHandle *)jarg1;
83525   if (!argp1) {
83526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83527     return 0;
83528   }
83529   arg1 = *argp1;
83530   {
83531     try {
83532       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83533     } catch (std::out_of_range& e) {
83534       {
83535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (std::exception& e) {
83538       {
83539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83540       };
83541     } catch (...) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83544       };
83545     }
83546   }
83547   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83548   return jresult;
83549 }
83550
83551
83552 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_0() {
83553   void * jresult ;
83554   Dali::Toolkit::GaussianBlurView result;
83555
83556   {
83557     try {
83558       result = Dali::Toolkit::GaussianBlurView::New();
83559     } catch (std::out_of_range& e) {
83560       {
83561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (std::exception& e) {
83564       {
83565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83566       };
83567     } catch (...) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83570       };
83571     }
83572   }
83573   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83574   return jresult;
83575 }
83576
83577
83578 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83579   void * jresult ;
83580   unsigned int arg1 ;
83581   float arg2 ;
83582   Dali::Pixel::Format arg3 ;
83583   float arg4 ;
83584   float arg5 ;
83585   bool arg6 ;
83586   Dali::Toolkit::GaussianBlurView result;
83587
83588   arg1 = (unsigned int)jarg1;
83589   arg2 = (float)jarg2;
83590   arg3 = (Dali::Pixel::Format)jarg3;
83591   arg4 = (float)jarg4;
83592   arg5 = (float)jarg5;
83593   arg6 = jarg6 ? true : false;
83594   {
83595     try {
83596       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83597     } catch (std::out_of_range& e) {
83598       {
83599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83600       };
83601     } catch (std::exception& e) {
83602       {
83603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83604       };
83605     } catch (...) {
83606       {
83607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83608       };
83609     }
83610   }
83611   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83617   void * jresult ;
83618   unsigned int arg1 ;
83619   float arg2 ;
83620   Dali::Pixel::Format arg3 ;
83621   float arg4 ;
83622   float arg5 ;
83623   Dali::Toolkit::GaussianBlurView result;
83624
83625   arg1 = (unsigned int)jarg1;
83626   arg2 = (float)jarg2;
83627   arg3 = (Dali::Pixel::Format)jarg3;
83628   arg4 = (float)jarg4;
83629   arg5 = (float)jarg5;
83630   {
83631     try {
83632       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83633     } catch (std::out_of_range& e) {
83634       {
83635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83636       };
83637     } catch (std::exception& e) {
83638       {
83639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83640       };
83641     } catch (...) {
83642       {
83643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83644       };
83645     }
83646   }
83647   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83648   return jresult;
83649 }
83650
83651
83652 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83653   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83654   Dali::Actor arg2 ;
83655   Dali::Actor *argp2 ;
83656
83657   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83658   argp2 = (Dali::Actor *)jarg2;
83659   if (!argp2) {
83660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83661     return ;
83662   }
83663   arg2 = *argp2;
83664   {
83665     try {
83666       (arg1)->Add(arg2);
83667     } catch (std::out_of_range& e) {
83668       {
83669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83670       };
83671     } catch (std::exception& e) {
83672       {
83673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83674       };
83675     } catch (...) {
83676       {
83677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83678       };
83679     }
83680   }
83681 }
83682
83683
83684 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83685   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83686   Dali::Actor arg2 ;
83687   Dali::Actor *argp2 ;
83688
83689   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83690   argp2 = (Dali::Actor *)jarg2;
83691   if (!argp2) {
83692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83693     return ;
83694   }
83695   arg2 = *argp2;
83696   {
83697     try {
83698       (arg1)->Remove(arg2);
83699     } catch (std::out_of_range& e) {
83700       {
83701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83702       };
83703     } catch (std::exception& e) {
83704       {
83705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83706       };
83707     } catch (...) {
83708       {
83709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83710       };
83711     }
83712   }
83713 }
83714
83715
83716 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Activate(void * jarg1) {
83717   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83718
83719   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83720   {
83721     try {
83722       (arg1)->Activate();
83723     } catch (std::out_of_range& e) {
83724       {
83725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83726       };
83727     } catch (std::exception& e) {
83728       {
83729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83730       };
83731     } catch (...) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83734       };
83735     }
83736   }
83737 }
83738
83739
83740 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_ActivateOnce(void * jarg1) {
83741   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83742
83743   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83744   {
83745     try {
83746       (arg1)->ActivateOnce();
83747     } catch (std::out_of_range& e) {
83748       {
83749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83750       };
83751     } catch (std::exception& e) {
83752       {
83753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83754       };
83755     } catch (...) {
83756       {
83757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83758       };
83759     }
83760   }
83761 }
83762
83763
83764 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_Deactivate(void * jarg1) {
83765   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83766
83767   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83768   {
83769     try {
83770       (arg1)->Deactivate();
83771     } catch (std::out_of_range& e) {
83772       {
83773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83774       };
83775     } catch (std::exception& e) {
83776       {
83777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83778       };
83779     } catch (...) {
83780       {
83781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83782       };
83783     }
83784   }
83785 }
83786
83787
83788 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83789   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83790   Dali::Image arg2 ;
83791   Dali::FrameBufferImage arg3 ;
83792   Dali::Image *argp2 ;
83793   Dali::FrameBufferImage *argp3 ;
83794
83795   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83796   argp2 = (Dali::Image *)jarg2;
83797   if (!argp2) {
83798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83799     return ;
83800   }
83801   arg2 = *argp2;
83802   argp3 = (Dali::FrameBufferImage *)jarg3;
83803   if (!argp3) {
83804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83805     return ;
83806   }
83807   arg3 = *argp3;
83808   {
83809     try {
83810       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83811     } catch (std::out_of_range& e) {
83812       {
83813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83814       };
83815     } catch (std::exception& e) {
83816       {
83817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83818       };
83819     } catch (...) {
83820       {
83821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83822       };
83823     }
83824   }
83825 }
83826
83827
83828 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83829   int jresult ;
83830   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83831   Dali::Property::Index result;
83832
83833   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83834   {
83835     try {
83836       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83837     } catch (std::out_of_range& e) {
83838       {
83839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83840       };
83841     } catch (std::exception& e) {
83842       {
83843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83844       };
83845     } catch (...) {
83846       {
83847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83848       };
83849     }
83850   }
83851   jresult = result;
83852   return jresult;
83853 }
83854
83855
83856 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83857   void * jresult ;
83858   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83859   Dali::FrameBufferImage result;
83860
83861   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83862   {
83863     try {
83864       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83865     } catch (std::out_of_range& e) {
83866       {
83867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83868       };
83869     } catch (std::exception& e) {
83870       {
83871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83872       };
83873     } catch (...) {
83874       {
83875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83876       };
83877     }
83878   }
83879   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83880   return jresult;
83881 }
83882
83883
83884 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83885   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83886   Dali::Vector4 *arg2 = 0 ;
83887
83888   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83889   arg2 = (Dali::Vector4 *)jarg2;
83890   if (!arg2) {
83891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83892     return ;
83893   }
83894   {
83895     try {
83896       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83897     } catch (std::out_of_range& e) {
83898       {
83899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83900       };
83901     } catch (std::exception& e) {
83902       {
83903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83904       };
83905     } catch (...) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83908       };
83909     }
83910   }
83911 }
83912
83913
83914 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83915   void * jresult ;
83916   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83917   Dali::Vector4 result;
83918
83919   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83920   {
83921     try {
83922       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83923     } catch (std::out_of_range& e) {
83924       {
83925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83926       };
83927     } catch (std::exception& e) {
83928       {
83929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83930       };
83931     } catch (...) {
83932       {
83933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83934       };
83935     }
83936   }
83937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83938   return jresult;
83939 }
83940
83941
83942 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_GaussianBlurView_FinishedSignal(void * jarg1) {
83943   void * jresult ;
83944   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83945   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83946
83947   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83948   {
83949     try {
83950       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83951     } catch (std::out_of_range& e) {
83952       {
83953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83954       };
83955     } catch (std::exception& e) {
83956       {
83957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83958       };
83959     } catch (...) {
83960       {
83961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83962       };
83963     }
83964   }
83965   jresult = (void *)result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageFactory(void * jarg1) {
83971   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83972
83973   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83974   {
83975     try {
83976       delete arg1;
83977     } catch (std::out_of_range& e) {
83978       {
83979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83980       };
83981     } catch (std::exception& e) {
83982       {
83983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83984       };
83985     } catch (...) {
83986       {
83987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83988       };
83989     }
83990   }
83991 }
83992
83993
83994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PageFactory_GetNumberOfPages(void * jarg1) {
83995   unsigned int jresult ;
83996   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83997   unsigned int result;
83998
83999   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84000   {
84001     try {
84002       result = (unsigned int)(arg1)->GetNumberOfPages();
84003     } catch (std::out_of_range& e) {
84004       {
84005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84006       };
84007     } catch (std::exception& e) {
84008       {
84009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84010       };
84011     } catch (...) {
84012       {
84013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84014       };
84015     }
84016   }
84017   jresult = result;
84018   return jresult;
84019 }
84020
84021
84022 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84023   void * jresult ;
84024   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84025   unsigned int arg2 ;
84026   Dali::Texture result;
84027
84028   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84029   arg2 = (unsigned int)jarg2;
84030   {
84031     try {
84032       result = (arg1)->NewPage(arg2);
84033     } catch (std::out_of_range& e) {
84034       {
84035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (std::exception& e) {
84038       {
84039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84040       };
84041     } catch (...) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84044       };
84045     }
84046   }
84047   jresult = new Dali::Texture((const Dali::Texture &)result);
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_PAGE_SIZE_get() {
84053   int jresult ;
84054   int result;
84055
84056   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84057   jresult = (int)result;
84058   return jresult;
84059 }
84060
84061
84062 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84063   int jresult ;
84064   int result;
84065
84066   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84067   jresult = (int)result;
84068   return jresult;
84069 }
84070
84071
84072 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_PageTurnView_Property_SPINE_SHADOW_get() {
84073   int jresult ;
84074   int result;
84075
84076   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84077   jresult = (int)result;
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView_Property() {
84083   void * jresult ;
84084   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84085
84086   {
84087     try {
84088       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84089     } catch (std::out_of_range& e) {
84090       {
84091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84092       };
84093     } catch (std::exception& e) {
84094       {
84095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84096       };
84097     } catch (...) {
84098       {
84099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84100       };
84101     }
84102   }
84103   jresult = (void *)result;
84104   return jresult;
84105 }
84106
84107
84108 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnView_Property(void * jarg1) {
84109   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84110
84111   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84112   {
84113     try {
84114       delete arg1;
84115     } catch (std::out_of_range& e) {
84116       {
84117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84118       };
84119     } catch (std::exception& e) {
84120       {
84121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84122       };
84123     } catch (...) {
84124       {
84125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84126       };
84127     }
84128   }
84129 }
84130
84131
84132 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView__SWIG_0() {
84133   void * jresult ;
84134   Dali::Toolkit::PageTurnView *result = 0 ;
84135
84136   {
84137     try {
84138       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84139     } catch (std::out_of_range& e) {
84140       {
84141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (std::exception& e) {
84144       {
84145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (...) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84150       };
84151     }
84152   }
84153   jresult = (void *)result;
84154   return jresult;
84155 }
84156
84157
84158 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnView__SWIG_1(void * jarg1) {
84159   void * jresult ;
84160   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84161   Dali::Toolkit::PageTurnView *result = 0 ;
84162
84163   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84164   if (!arg1) {
84165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84166     return 0;
84167   }
84168   {
84169     try {
84170       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84171     } catch (std::out_of_range& e) {
84172       {
84173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84174       };
84175     } catch (std::exception& e) {
84176       {
84177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84178       };
84179     } catch (...) {
84180       {
84181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84182       };
84183     }
84184   }
84185   jresult = (void *)result;
84186   return jresult;
84187 }
84188
84189
84190 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_Assign(void * jarg1, void * jarg2) {
84191   void * jresult ;
84192   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84193   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84194   Dali::Toolkit::PageTurnView *result = 0 ;
84195
84196   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84197   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84198   if (!arg2) {
84199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84200     return 0;
84201   }
84202   {
84203     try {
84204       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84216       };
84217     }
84218   }
84219   jresult = (void *)result;
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnView(void * jarg1) {
84225   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84226
84227   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84228   {
84229     try {
84230       delete arg1;
84231     } catch (std::out_of_range& e) {
84232       {
84233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84234       };
84235     } catch (std::exception& e) {
84236       {
84237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84238       };
84239     } catch (...) {
84240       {
84241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84242       };
84243     }
84244   }
84245 }
84246
84247
84248 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_DownCast(void * jarg1) {
84249   void * jresult ;
84250   Dali::BaseHandle arg1 ;
84251   Dali::BaseHandle *argp1 ;
84252   Dali::Toolkit::PageTurnView result;
84253
84254   argp1 = (Dali::BaseHandle *)jarg1;
84255   if (!argp1) {
84256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84257     return 0;
84258   }
84259   arg1 = *argp1;
84260   {
84261     try {
84262       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84263     } catch (std::out_of_range& e) {
84264       {
84265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84266       };
84267     } catch (std::exception& e) {
84268       {
84269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84270       };
84271     } catch (...) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84274       };
84275     }
84276   }
84277   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84278   return jresult;
84279 }
84280
84281
84282 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84283   void * jresult ;
84284   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84285   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84286
84287   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84288   {
84289     try {
84290       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84291     } catch (std::out_of_range& e) {
84292       {
84293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84294       };
84295     } catch (std::exception& e) {
84296       {
84297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (...) {
84300       {
84301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84302       };
84303     }
84304   }
84305   jresult = (void *)result;
84306   return jresult;
84307 }
84308
84309
84310 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84311   void * jresult ;
84312   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84313   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84314
84315   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84316   {
84317     try {
84318       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84319     } catch (std::out_of_range& e) {
84320       {
84321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84322       };
84323     } catch (std::exception& e) {
84324       {
84325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84326       };
84327     } catch (...) {
84328       {
84329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84330       };
84331     }
84332   }
84333   jresult = (void *)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PagePanStartedSignal(void * jarg1) {
84339   void * jresult ;
84340   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84341   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84342
84343   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84344   {
84345     try {
84346       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84347     } catch (std::out_of_range& e) {
84348       {
84349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84350       };
84351     } catch (std::exception& e) {
84352       {
84353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84354       };
84355     } catch (...) {
84356       {
84357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84358       };
84359     }
84360   }
84361   jresult = (void *)result;
84362   return jresult;
84363 }
84364
84365
84366 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84367   void * jresult ;
84368   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84369   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84370
84371   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84372   {
84373     try {
84374       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84375     } catch (std::out_of_range& e) {
84376       {
84377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84378       };
84379     } catch (std::exception& e) {
84380       {
84381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84382       };
84383     } catch (...) {
84384       {
84385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84386       };
84387     }
84388   }
84389   jresult = (void *)result;
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnLandscapeView__SWIG_0() {
84395   void * jresult ;
84396   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84397
84398   {
84399     try {
84400       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84401     } catch (std::out_of_range& e) {
84402       {
84403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84404       };
84405     } catch (std::exception& e) {
84406       {
84407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84408       };
84409     } catch (...) {
84410       {
84411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84412       };
84413     }
84414   }
84415   jresult = (void *)result;
84416   return jresult;
84417 }
84418
84419
84420 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84421   void * jresult ;
84422   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84423   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84424
84425   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84426   if (!arg1) {
84427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84428     return 0;
84429   }
84430   {
84431     try {
84432       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84433     } catch (std::out_of_range& e) {
84434       {
84435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84436       };
84437     } catch (std::exception& e) {
84438       {
84439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84440       };
84441     } catch (...) {
84442       {
84443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84444       };
84445     }
84446   }
84447   jresult = (void *)result;
84448   return jresult;
84449 }
84450
84451
84452 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84453   void * jresult ;
84454   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84455   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84456   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84457
84458   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84459   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84460   if (!arg2) {
84461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84462     return 0;
84463   }
84464   {
84465     try {
84466       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84467     } catch (std::out_of_range& e) {
84468       {
84469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84470       };
84471     } catch (std::exception& e) {
84472       {
84473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84474       };
84475     } catch (...) {
84476       {
84477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84478       };
84479     }
84480   }
84481   jresult = (void *)result;
84482   return jresult;
84483 }
84484
84485
84486 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnLandscapeView(void * jarg1) {
84487   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84488
84489   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84490   {
84491     try {
84492       delete arg1;
84493     } catch (std::out_of_range& e) {
84494       {
84495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84496       };
84497     } catch (std::exception& e) {
84498       {
84499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84500       };
84501     } catch (...) {
84502       {
84503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84504       };
84505     }
84506   }
84507 }
84508
84509
84510 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84511   void * jresult ;
84512   Dali::Toolkit::PageFactory *arg1 = 0 ;
84513   Dali::Vector2 *arg2 = 0 ;
84514   Dali::Toolkit::PageTurnLandscapeView result;
84515
84516   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84517   if (!arg1) {
84518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84519     return 0;
84520   }
84521   arg2 = (Dali::Vector2 *)jarg2;
84522   if (!arg2) {
84523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84524     return 0;
84525   }
84526   {
84527     try {
84528       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84529     } catch (std::out_of_range& e) {
84530       {
84531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84532       };
84533     } catch (std::exception& e) {
84534       {
84535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84536       };
84537     } catch (...) {
84538       {
84539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84540       };
84541     }
84542   }
84543   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84544   return jresult;
84545 }
84546
84547
84548 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_DownCast(void * jarg1) {
84549   void * jresult ;
84550   Dali::BaseHandle arg1 ;
84551   Dali::BaseHandle *argp1 ;
84552   Dali::Toolkit::PageTurnLandscapeView result;
84553
84554   argp1 = (Dali::BaseHandle *)jarg1;
84555   if (!argp1) {
84556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84557     return 0;
84558   }
84559   arg1 = *argp1;
84560   {
84561     try {
84562       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84563     } catch (std::out_of_range& e) {
84564       {
84565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (std::exception& e) {
84568       {
84569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84574       };
84575     }
84576   }
84577   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84578   return jresult;
84579 }
84580
84581
84582 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnPortraitView__SWIG_0() {
84583   void * jresult ;
84584   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84585
84586   {
84587     try {
84588       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84589     } catch (std::out_of_range& e) {
84590       {
84591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84592       };
84593     } catch (std::exception& e) {
84594       {
84595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84596       };
84597     } catch (...) {
84598       {
84599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84600       };
84601     }
84602   }
84603   jresult = (void *)result;
84604   return jresult;
84605 }
84606
84607
84608 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84609   void * jresult ;
84610   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84611   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84612
84613   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84614   if (!arg1) {
84615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84616     return 0;
84617   }
84618   {
84619     try {
84620       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84621     } catch (std::out_of_range& e) {
84622       {
84623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84624       };
84625     } catch (std::exception& e) {
84626       {
84627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84628       };
84629     } catch (...) {
84630       {
84631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84632       };
84633     }
84634   }
84635   jresult = (void *)result;
84636   return jresult;
84637 }
84638
84639
84640 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84641   void * jresult ;
84642   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84643   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84644   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84645
84646   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84647   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84648   if (!arg2) {
84649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84650     return 0;
84651   }
84652   {
84653     try {
84654       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84655     } catch (std::out_of_range& e) {
84656       {
84657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84658       };
84659     } catch (std::exception& e) {
84660       {
84661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84662       };
84663     } catch (...) {
84664       {
84665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84666       };
84667     }
84668   }
84669   jresult = (void *)result;
84670   return jresult;
84671 }
84672
84673
84674 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnPortraitView(void * jarg1) {
84675   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84676
84677   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84678   {
84679     try {
84680       delete arg1;
84681     } catch (std::out_of_range& e) {
84682       {
84683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84684       };
84685     } catch (std::exception& e) {
84686       {
84687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84688       };
84689     } catch (...) {
84690       {
84691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84692       };
84693     }
84694   }
84695 }
84696
84697
84698 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84699   void * jresult ;
84700   Dali::Toolkit::PageFactory *arg1 = 0 ;
84701   Dali::Vector2 *arg2 = 0 ;
84702   Dali::Toolkit::PageTurnPortraitView result;
84703
84704   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84705   if (!arg1) {
84706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84707     return 0;
84708   }
84709   arg2 = (Dali::Vector2 *)jarg2;
84710   if (!arg2) {
84711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84712     return 0;
84713   }
84714   {
84715     try {
84716       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84717     } catch (std::out_of_range& e) {
84718       {
84719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (std::exception& e) {
84722       {
84723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84728       };
84729     }
84730   }
84731   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84732   return jresult;
84733 }
84734
84735
84736 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_DownCast(void * jarg1) {
84737   void * jresult ;
84738   Dali::BaseHandle arg1 ;
84739   Dali::BaseHandle *argp1 ;
84740   Dali::Toolkit::PageTurnPortraitView result;
84741
84742   argp1 = (Dali::BaseHandle *)jarg1;
84743   if (!argp1) {
84744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84745     return 0;
84746   }
84747   arg1 = *argp1;
84748   {
84749     try {
84750       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84762       };
84763     }
84764   }
84765   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84766   return jresult;
84767 }
84768
84769
84770 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_0() {
84771   void * jresult ;
84772   Dali::Toolkit::Visual::Base *result = 0 ;
84773
84774   {
84775     try {
84776       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VisualBase(void * jarg1) {
84797   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84798
84799   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84800   {
84801     try {
84802       delete arg1;
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84810       };
84811     } catch (...) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84814       };
84815     }
84816   }
84817 }
84818
84819
84820 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_1(void * jarg1) {
84821   void * jresult ;
84822   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84823   Dali::Toolkit::Visual::Base *result = 0 ;
84824
84825   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84826   if (!arg1) {
84827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84828     return 0;
84829   }
84830   {
84831     try {
84832       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84833     } catch (std::out_of_range& e) {
84834       {
84835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (std::exception& e) {
84838       {
84839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (...) {
84842       {
84843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84844       };
84845     }
84846   }
84847   jresult = (void *)result;
84848   return jresult;
84849 }
84850
84851
84852 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualBase_Assign(void * jarg1, void * jarg2) {
84853   void * jresult ;
84854   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84855   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84856   Dali::Toolkit::Visual::Base *result = 0 ;
84857
84858   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84859   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84860   if (!arg2) {
84861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84862     return 0;
84863   }
84864   {
84865     try {
84866       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84867     } catch (std::out_of_range& e) {
84868       {
84869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84870       };
84871     } catch (std::exception& e) {
84872       {
84873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84874       };
84875     } catch (...) {
84876       {
84877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84878       };
84879     }
84880   }
84881   jresult = (void *)result;
84882   return jresult;
84883 }
84884
84885
84886 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetName(void * jarg1, char * jarg2) {
84887   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84888   std::string *arg2 = 0 ;
84889
84890   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84891   if (!jarg2) {
84892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84893     return ;
84894   }
84895   std::string arg2_str(jarg2);
84896   arg2 = &arg2_str;
84897   {
84898     try {
84899       (arg1)->SetName((std::string const &)*arg2);
84900     } catch (std::out_of_range& e) {
84901       {
84902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84903       };
84904     } catch (std::exception& e) {
84905       {
84906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84907       };
84908     } catch (...) {
84909       {
84910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84911       };
84912     }
84913   }
84914
84915   //argout typemap for const std::string&
84916
84917 }
84918
84919
84920 SWIGEXPORT char * SWIGSTDCALL CSharp_NUI_VisualBase_GetName(void * jarg1) {
84921   char * jresult ;
84922   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84923   std::string *result = 0 ;
84924
84925   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84926   {
84927     try {
84928       result = (std::string *) &(arg1)->GetName();
84929     } catch (std::out_of_range& e) {
84930       {
84931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84932       };
84933     } catch (std::exception& e) {
84934       {
84935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84936       };
84937     } catch (...) {
84938       {
84939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84940       };
84941     }
84942   }
84943   jresult = SWIG_csharp_string_callback(result->c_str());
84944   return jresult;
84945 }
84946
84947 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84948   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84949   Dali::Property::Map *arg2 = 0 ;
84950   Dali::Size arg3 ;
84951   Dali::Size *argp3 ;
84952
84953   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84954   arg2 = (Dali::Property::Map *)jarg2;
84955   if (!arg2) {
84956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84957     return ;
84958   }
84959   argp3 = (Dali::Size *)jarg3;
84960   if (!argp3) {
84961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84962     return ;
84963   }
84964   arg3 = *argp3;
84965   {
84966     try {
84967       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84968     } catch (std::out_of_range& e) {
84969       {
84970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84971       };
84972     } catch (std::exception& e) {
84973       {
84974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84975       };
84976     } catch (...) {
84977       {
84978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84979       };
84980     }
84981   }
84982 }
84983
84984
84985 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84986   float jresult ;
84987   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84988   float arg2 ;
84989   float result;
84990
84991   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84992   arg2 = (float)jarg2;
84993   {
84994     try {
84995       result = (float)(arg1)->GetHeightForWidth(arg2);
84996     } catch (std::out_of_range& e) {
84997       {
84998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84999       };
85000     } catch (std::exception& e) {
85001       {
85002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85003       };
85004     } catch (...) {
85005       {
85006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85007       };
85008     }
85009   }
85010   jresult = result;
85011   return jresult;
85012 }
85013
85014
85015 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85016   float jresult ;
85017   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85018   float arg2 ;
85019   float result;
85020
85021   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85022   arg2 = (float)jarg2;
85023   {
85024     try {
85025       result = (float)(arg1)->GetWidthForHeight(arg2);
85026     } catch (std::out_of_range& e) {
85027       {
85028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (std::exception& e) {
85031       {
85032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85037       };
85038     }
85039   }
85040   jresult = result;
85041   return jresult;
85042 }
85043
85044
85045 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85046   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85047   Dali::Vector2 *arg2 = 0 ;
85048
85049   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85050   arg2 = (Dali::Vector2 *)jarg2;
85051   if (!arg2) {
85052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85053     return ;
85054   }
85055   {
85056     try {
85057       (arg1)->GetNaturalSize(*arg2);
85058     } catch (std::out_of_range& e) {
85059       {
85060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85061       };
85062     } catch (std::exception& e) {
85063       {
85064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85065       };
85066     } catch (...) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85069       };
85070     }
85071   }
85072 }
85073
85074
85075 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85076   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85077   float arg2 ;
85078
85079   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85080   arg2 = (float)jarg2;
85081   {
85082     try {
85083       (arg1)->SetDepthIndex(arg2);
85084     } catch (std::out_of_range& e) {
85085       {
85086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85087       };
85088     } catch (std::exception& e) {
85089       {
85090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85091       };
85092     } catch (...) {
85093       {
85094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85095       };
85096     }
85097   }
85098 }
85099
85100
85101 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_VisualBase_GetDepthIndex(void * jarg1) {
85102   float jresult ;
85103   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85104   float result;
85105
85106   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85107   {
85108     try {
85109       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85110     } catch (std::out_of_range& e) {
85111       {
85112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85113       };
85114     } catch (std::exception& e) {
85115       {
85116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85117       };
85118     } catch (...) {
85119       {
85120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85121       };
85122     }
85123   }
85124   jresult = result;
85125   return jresult;
85126 }
85127
85128
85129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85130   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85131   Dali::Property::Map *arg2 = 0 ;
85132
85133   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85134   arg2 = (Dali::Property::Map *)jarg2;
85135   if (!arg2) {
85136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85137     return ;
85138   }
85139   {
85140     try {
85141       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85142     } catch (std::out_of_range& e) {
85143       {
85144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85145       };
85146     } catch (std::exception& e) {
85147       {
85148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85149       };
85150     } catch (...) {
85151       {
85152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85153       };
85154     }
85155   }
85156 }
85157
85158
85159 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualBase__SWIG_2(void * jarg1) {
85160   void * jresult ;
85161   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85162   Dali::Toolkit::Visual::Base *result = 0 ;
85163
85164   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85165   {
85166     try {
85167       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85168     } catch (std::out_of_range& e) {
85169       {
85170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85171       };
85172     } catch (std::exception& e) {
85173       {
85174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (...) {
85177       {
85178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85179       };
85180     }
85181   }
85182   jresult = (void *)result;
85183   return jresult;
85184 }
85185
85186
85187 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_Get() {
85188   void * jresult ;
85189   Dali::Toolkit::VisualFactory result;
85190
85191   {
85192     try {
85193       result = Dali::Toolkit::VisualFactory::Get();
85194     } catch (std::out_of_range& e) {
85195       {
85196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85197       };
85198     } catch (std::exception& e) {
85199       {
85200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (...) {
85203       {
85204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85205       };
85206     }
85207   }
85208   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85209   return jresult;
85210 }
85211
85212
85213 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualFactory__SWIG_0() {
85214   void * jresult ;
85215   Dali::Toolkit::VisualFactory *result = 0 ;
85216
85217   {
85218     try {
85219       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85220     } catch (std::out_of_range& e) {
85221       {
85222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85223       };
85224     } catch (std::exception& e) {
85225       {
85226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85227       };
85228     } catch (...) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85231       };
85232     }
85233   }
85234   jresult = (void *)result;
85235   return jresult;
85236 }
85237
85238
85239 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VisualFactory(void * jarg1) {
85240   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85241
85242   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85243   {
85244     try {
85245       delete arg1;
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85257       };
85258     }
85259   }
85260 }
85261
85262
85263 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VisualFactory__SWIG_1(void * jarg1) {
85264   void * jresult ;
85265   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85266   Dali::Toolkit::VisualFactory *result = 0 ;
85267
85268   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85269   if (!arg1) {
85270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85271     return 0;
85272   }
85273   {
85274     try {
85275       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85276     } catch (std::out_of_range& e) {
85277       {
85278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85279       };
85280     } catch (std::exception& e) {
85281       {
85282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85283       };
85284     } catch (...) {
85285       {
85286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85287       };
85288     }
85289   }
85290   jresult = (void *)result;
85291   return jresult;
85292 }
85293
85294
85295 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_Assign(void * jarg1, void * jarg2) {
85296   void * jresult ;
85297   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85298   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85299   Dali::Toolkit::VisualFactory *result = 0 ;
85300
85301   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85302   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85303   if (!arg2) {
85304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85305     return 0;
85306   }
85307   {
85308     try {
85309       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (...) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85321       };
85322     }
85323   }
85324   jresult = (void *)result;
85325   return jresult;
85326 }
85327
85328
85329 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85330   void * jresult ;
85331   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85332   Dali::Property::Map *arg2 = 0 ;
85333   Dali::Toolkit::Visual::Base result;
85334
85335   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85336   arg2 = (Dali::Property::Map *)jarg2;
85337   if (!arg2) {
85338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85339     return 0;
85340   }
85341   {
85342     try {
85343       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85344     } catch (std::out_of_range& e) {
85345       {
85346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85347       };
85348     } catch (std::exception& e) {
85349       {
85350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85351       };
85352     } catch (...) {
85353       {
85354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85355       };
85356     }
85357   }
85358   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85364   void * jresult ;
85365   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85366   Dali::Image *arg2 = 0 ;
85367   Dali::Toolkit::Visual::Base result;
85368
85369   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85370   arg2 = (Dali::Image *)jarg2;
85371   if (!arg2) {
85372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85373     return 0;
85374   }
85375   {
85376     try {
85377       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85378     } catch (std::out_of_range& e) {
85379       {
85380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (std::exception& e) {
85383       {
85384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (...) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85389       };
85390     }
85391   }
85392   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85393   return jresult;
85394 }
85395
85396
85397 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85398   void * jresult ;
85399   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85400   std::string *arg2 = 0 ;
85401   Dali::ImageDimensions arg3 ;
85402   Dali::ImageDimensions *argp3 ;
85403   Dali::Toolkit::Visual::Base result;
85404
85405   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85406   if (!jarg2) {
85407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85408     return 0;
85409   }
85410   std::string arg2_str(jarg2);
85411   arg2 = &arg2_str;
85412   argp3 = (Dali::ImageDimensions *)jarg3;
85413   if (!argp3) {
85414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85415     return 0;
85416   }
85417   arg3 = *argp3;
85418   {
85419     try {
85420       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85421     } catch (std::out_of_range& e) {
85422       {
85423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (std::exception& e) {
85426       {
85427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85428       };
85429     } catch (...) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85432       };
85433     }
85434   }
85435   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85436
85437   //argout typemap for const std::string&
85438
85439   return jresult;
85440 }
85441
85442
85443 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_0() {
85444   void * jresult ;
85445   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85446
85447   {
85448     try {
85449       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85450     } catch (std::out_of_range& e) {
85451       {
85452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85453       };
85454     } catch (std::exception& e) {
85455       {
85456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (...) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85461       };
85462     }
85463   }
85464   jresult = (void *)result;
85465   return jresult;
85466 }
85467
85468
85469 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AsyncImageLoader(void * jarg1) {
85470   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85471
85472   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85473   {
85474     try {
85475       delete arg1;
85476     } catch (std::out_of_range& e) {
85477       {
85478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (std::exception& e) {
85481       {
85482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85487       };
85488     }
85489   }
85490 }
85491
85492
85493 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85494   void * jresult ;
85495   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85496   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85497
85498   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85499   if (!arg1) {
85500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85501     return 0;
85502   }
85503   {
85504     try {
85505       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85506     } catch (std::out_of_range& e) {
85507       {
85508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85509       };
85510     } catch (std::exception& e) {
85511       {
85512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85513       };
85514     } catch (...) {
85515       {
85516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85517       };
85518     }
85519   }
85520   jresult = (void *)result;
85521   return jresult;
85522 }
85523
85524
85525 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85526   void * jresult ;
85527   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85528   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85529   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85530
85531   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85532   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85533   if (!arg2) {
85534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85535     return 0;
85536   }
85537   {
85538     try {
85539       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85540     } catch (std::out_of_range& e) {
85541       {
85542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85543       };
85544     } catch (std::exception& e) {
85545       {
85546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (...) {
85549       {
85550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85551       };
85552     }
85553   }
85554   jresult = (void *)result;
85555   return jresult;
85556 }
85557
85558
85559 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_New() {
85560   void * jresult ;
85561   Dali::Toolkit::AsyncImageLoader result;
85562
85563   {
85564     try {
85565       result = Dali::Toolkit::AsyncImageLoader::New();
85566     } catch (std::out_of_range& e) {
85567       {
85568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85569       };
85570     } catch (std::exception& e) {
85571       {
85572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85573       };
85574     } catch (...) {
85575       {
85576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85577       };
85578     }
85579   }
85580   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85581   return jresult;
85582 }
85583
85584
85585 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_DownCast(void * jarg1) {
85586   void * jresult ;
85587   Dali::BaseHandle arg1 ;
85588   Dali::BaseHandle *argp1 ;
85589   Dali::Toolkit::AsyncImageLoader result;
85590
85591   argp1 = (Dali::BaseHandle *)jarg1;
85592   if (!argp1) {
85593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85594     return 0;
85595   }
85596   arg1 = *argp1;
85597   {
85598     try {
85599       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85600     } catch (std::out_of_range& e) {
85601       {
85602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85603       };
85604     } catch (std::exception& e) {
85605       {
85606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85607       };
85608     } catch (...) {
85609       {
85610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85611       };
85612     }
85613   }
85614   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85615   return jresult;
85616 }
85617
85618
85619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85620   unsigned int jresult ;
85621   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85622   std::string *arg2 = 0 ;
85623   uint32_t result;
85624
85625   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85626   if (!jarg2) {
85627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85628     return 0;
85629   }
85630   std::string arg2_str(jarg2);
85631   arg2 = &arg2_str;
85632   {
85633     try {
85634       result = (arg1)->Load((std::string const &)*arg2);
85635     } catch (std::out_of_range& e) {
85636       {
85637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85638       };
85639     } catch (std::exception& e) {
85640       {
85641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85646       };
85647     }
85648   }
85649   jresult = result;
85650
85651   //argout typemap for const std::string&
85652
85653   return jresult;
85654 }
85655
85656
85657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85658   unsigned int jresult ;
85659   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85660   std::string *arg2 = 0 ;
85661   Dali::ImageDimensions arg3 ;
85662   Dali::ImageDimensions *argp3 ;
85663   uint32_t result;
85664
85665   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85666   if (!jarg2) {
85667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85668     return 0;
85669   }
85670   std::string arg2_str(jarg2);
85671   arg2 = &arg2_str;
85672   argp3 = (Dali::ImageDimensions *)jarg3;
85673   if (!argp3) {
85674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85675     return 0;
85676   }
85677   arg3 = *argp3;
85678   {
85679     try {
85680       result = (arg1)->Load((std::string const &)*arg2,arg3);
85681     } catch (std::out_of_range& e) {
85682       {
85683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85684       };
85685     } catch (std::exception& e) {
85686       {
85687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85688       };
85689     } catch (...) {
85690       {
85691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85692       };
85693     }
85694   }
85695   jresult = result;
85696
85697   //argout typemap for const std::string&
85698
85699   return jresult;
85700 }
85701
85702
85703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85704   unsigned int jresult ;
85705   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85706   std::string *arg2 = 0 ;
85707   Dali::ImageDimensions arg3 ;
85708   Dali::FittingMode::Type arg4 ;
85709   Dali::SamplingMode::Type arg5 ;
85710   bool arg6 ;
85711   Dali::ImageDimensions *argp3 ;
85712   uint32_t result;
85713
85714   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85715   if (!jarg2) {
85716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85717     return 0;
85718   }
85719   std::string arg2_str(jarg2);
85720   arg2 = &arg2_str;
85721   argp3 = (Dali::ImageDimensions *)jarg3;
85722   if (!argp3) {
85723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85724     return 0;
85725   }
85726   arg3 = *argp3;
85727   arg4 = (Dali::FittingMode::Type)jarg4;
85728   arg5 = (Dali::SamplingMode::Type)jarg5;
85729   arg6 = jarg6 ? true : false;
85730   {
85731     try {
85732       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85733     } catch (std::out_of_range& e) {
85734       {
85735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85736       };
85737     } catch (std::exception& e) {
85738       {
85739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85740       };
85741     } catch (...) {
85742       {
85743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85744       };
85745     }
85746   }
85747   jresult = result;
85748
85749   //argout typemap for const std::string&
85750
85751   return jresult;
85752 }
85753
85754
85755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85756   unsigned int jresult ;
85757   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85758   uint32_t arg2 ;
85759   bool result;
85760
85761   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85762   arg2 = (uint32_t)jarg2;
85763   {
85764     try {
85765       result = (bool)(arg1)->Cancel(arg2);
85766     } catch (std::out_of_range& e) {
85767       {
85768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85769       };
85770     } catch (std::exception& e) {
85771       {
85772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (...) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85777       };
85778     }
85779   }
85780   jresult = result;
85781   return jresult;
85782 }
85783
85784
85785 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AsyncImageLoader_CancelAll(void * jarg1) {
85786   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85787
85788   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85789   {
85790     try {
85791       (arg1)->CancelAll();
85792     } catch (std::out_of_range& e) {
85793       {
85794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85795       };
85796     } catch (std::exception& e) {
85797       {
85798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85799       };
85800     } catch (...) {
85801       {
85802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85803       };
85804     }
85805   }
85806 }
85807
85808
85809 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85810   void * jresult ;
85811   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85812   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85813
85814   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85815   {
85816     try {
85817       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85818     } catch (std::out_of_range& e) {
85819       {
85820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85821       };
85822     } catch (std::exception& e) {
85823       {
85824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (...) {
85827       {
85828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85829       };
85830     }
85831   }
85832   jresult = (void *)result;
85833   return jresult;
85834 }
85835
85836
85837 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85838   void * jresult ;
85839   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85840   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85841
85842   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85843   {
85844     try {
85845       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85846     } catch (std::out_of_range& e) {
85847       {
85848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85849       };
85850     } catch (std::exception& e) {
85851       {
85852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (...) {
85855       {
85856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85857       };
85858     }
85859   }
85860   jresult = (void *)result;
85861   return jresult;
85862 }
85863
85864
85865 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_0(char * jarg1) {
85866   void * jresult ;
85867   std::string *arg1 = 0 ;
85868   Dali::PixelData result;
85869
85870   if (!jarg1) {
85871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85872     return 0;
85873   }
85874   std::string arg1_str(jarg1);
85875   arg1 = &arg1_str;
85876   {
85877     try {
85878       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85879     } catch (std::out_of_range& e) {
85880       {
85881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85882       };
85883     } catch (std::exception& e) {
85884       {
85885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (...) {
85888       {
85889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85890       };
85891     }
85892   }
85893   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85894
85895   //argout typemap for const std::string&
85896
85897   return jresult;
85898 }
85899
85900
85901 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85902   void * jresult ;
85903   std::string *arg1 = 0 ;
85904   Dali::ImageDimensions arg2 ;
85905   Dali::ImageDimensions *argp2 ;
85906   Dali::PixelData result;
85907
85908   if (!jarg1) {
85909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85910     return 0;
85911   }
85912   std::string arg1_str(jarg1);
85913   arg1 = &arg1_str;
85914   argp2 = (Dali::ImageDimensions *)jarg2;
85915   if (!argp2) {
85916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85917     return 0;
85918   }
85919   arg2 = *argp2;
85920   {
85921     try {
85922       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (...) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85934       };
85935     }
85936   }
85937   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85938
85939   //argout typemap for const std::string&
85940
85941   return jresult;
85942 }
85943
85944
85945 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85946   void * jresult ;
85947   std::string *arg1 = 0 ;
85948   Dali::ImageDimensions arg2 ;
85949   Dali::FittingMode::Type arg3 ;
85950   Dali::SamplingMode::Type arg4 ;
85951   bool arg5 ;
85952   Dali::ImageDimensions *argp2 ;
85953   Dali::PixelData result;
85954
85955   if (!jarg1) {
85956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85957     return 0;
85958   }
85959   std::string arg1_str(jarg1);
85960   arg1 = &arg1_str;
85961   argp2 = (Dali::ImageDimensions *)jarg2;
85962   if (!argp2) {
85963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85964     return 0;
85965   }
85966   arg2 = *argp2;
85967   arg3 = (Dali::FittingMode::Type)jarg3;
85968   arg4 = (Dali::SamplingMode::Type)jarg4;
85969   arg5 = jarg5 ? true : false;
85970   {
85971     try {
85972       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85973     } catch (std::out_of_range& e) {
85974       {
85975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85976       };
85977     } catch (std::exception& e) {
85978       {
85979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85980       };
85981     } catch (...) {
85982       {
85983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85984       };
85985     }
85986   }
85987   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85988
85989   //argout typemap for const std::string&
85990
85991   return jresult;
85992 }
85993
85994
85995 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Clear(void * jarg1) {
85996   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85997
85998   arg1 = (std::vector< unsigned int > *)jarg1;
85999   {
86000     try {
86001       (arg1)->clear();
86002     } catch (std::out_of_range& e) {
86003       {
86004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86005       };
86006     } catch (std::exception& e) {
86007       {
86008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86009       };
86010     } catch (...) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86013       };
86014     }
86015   }
86016 }
86017
86018
86019 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86020   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86021   unsigned int *arg2 = 0 ;
86022   unsigned int temp2 ;
86023
86024   arg1 = (std::vector< unsigned int > *)jarg1;
86025   temp2 = (unsigned int)jarg2;
86026   arg2 = &temp2;
86027   {
86028     try {
86029       (arg1)->push_back((unsigned int const &)*arg2);
86030     } catch (std::out_of_range& e) {
86031       {
86032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86033       };
86034     } catch (std::exception& e) {
86035       {
86036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86041       };
86042     }
86043   }
86044 }
86045
86046
86047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemIdContainer_size(void * jarg1) {
86048   unsigned long jresult ;
86049   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86050   std::vector< unsigned int >::size_type result;
86051
86052   arg1 = (std::vector< unsigned int > *)jarg1;
86053   {
86054     try {
86055       result = ((std::vector< unsigned int > const *)arg1)->size();
86056     } catch (std::out_of_range& e) {
86057       {
86058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86059       };
86060     } catch (std::exception& e) {
86061       {
86062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86063       };
86064     } catch (...) {
86065       {
86066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86067       };
86068     }
86069   }
86070   jresult = (unsigned long)result;
86071   return jresult;
86072 }
86073
86074
86075 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemIdContainer_capacity(void * jarg1) {
86076   unsigned long jresult ;
86077   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86078   std::vector< unsigned int >::size_type result;
86079
86080   arg1 = (std::vector< unsigned int > *)jarg1;
86081   {
86082     try {
86083       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86084     } catch (std::out_of_range& e) {
86085       {
86086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86087       };
86088     } catch (std::exception& e) {
86089       {
86090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (...) {
86093       {
86094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86095       };
86096     }
86097   }
86098   jresult = (unsigned long)result;
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86104   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86105   std::vector< unsigned int >::size_type arg2 ;
86106
86107   arg1 = (std::vector< unsigned int > *)jarg1;
86108   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86109   {
86110     try {
86111       (arg1)->reserve(arg2);
86112     } catch (std::out_of_range& e) {
86113       {
86114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86115       };
86116     } catch (std::exception& e) {
86117       {
86118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86119       };
86120     } catch (...) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86123       };
86124     }
86125   }
86126 }
86127
86128
86129 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_0() {
86130   void * jresult ;
86131   std::vector< unsigned int > *result = 0 ;
86132
86133   {
86134     try {
86135       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86136     } catch (std::out_of_range& e) {
86137       {
86138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (std::exception& e) {
86141       {
86142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86147       };
86148     }
86149   }
86150   jresult = (void *)result;
86151   return jresult;
86152 }
86153
86154
86155 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_1(void * jarg1) {
86156   void * jresult ;
86157   std::vector< unsigned int > *arg1 = 0 ;
86158   std::vector< unsigned int > *result = 0 ;
86159
86160   arg1 = (std::vector< unsigned int > *)jarg1;
86161   if (!arg1) {
86162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86163     return 0;
86164   }
86165   {
86166     try {
86167       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86168     } catch (std::out_of_range& e) {
86169       {
86170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86171       };
86172     } catch (std::exception& e) {
86173       {
86174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86175       };
86176     } catch (...) {
86177       {
86178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86179       };
86180     }
86181   }
86182   jresult = (void *)result;
86183   return jresult;
86184 }
86185
86186
86187 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemIdContainer__SWIG_2(int jarg1) {
86188   void * jresult ;
86189   int arg1 ;
86190   std::vector< unsigned int > *result = 0 ;
86191
86192   arg1 = (int)jarg1;
86193   {
86194     try {
86195       try {
86196         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86197       }
86198       catch(std::out_of_range &_e) {
86199         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86200         return 0;
86201       }
86202
86203     } catch (std::out_of_range& e) {
86204       {
86205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (std::exception& e) {
86208       {
86209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86210       };
86211     } catch (...) {
86212       {
86213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86214       };
86215     }
86216   }
86217   jresult = (void *)result;
86218   return jresult;
86219 }
86220
86221
86222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86223   unsigned int jresult ;
86224   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86225   int arg2 ;
86226   unsigned int result;
86227
86228   arg1 = (std::vector< unsigned int > *)jarg1;
86229   arg2 = (int)jarg2;
86230   {
86231     try {
86232       try {
86233         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86234       }
86235       catch(std::out_of_range &_e) {
86236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86237         return 0;
86238       }
86239
86240     } catch (std::out_of_range& e) {
86241       {
86242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86243       };
86244     } catch (std::exception& e) {
86245       {
86246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86247       };
86248     } catch (...) {
86249       {
86250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86251       };
86252     }
86253   }
86254   jresult = result;
86255   return jresult;
86256 }
86257
86258
86259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86260   unsigned int jresult ;
86261   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86262   int arg2 ;
86263   unsigned int *result = 0 ;
86264
86265   arg1 = (std::vector< unsigned int > *)jarg1;
86266   arg2 = (int)jarg2;
86267   {
86268     try {
86269       try {
86270         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86271       }
86272       catch(std::out_of_range &_e) {
86273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86274         return 0;
86275       }
86276
86277     } catch (std::out_of_range& e) {
86278       {
86279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (std::exception& e) {
86282       {
86283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (...) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86288       };
86289     }
86290   }
86291   jresult = *result;
86292   return jresult;
86293 }
86294
86295
86296 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86297   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86298   int arg2 ;
86299   unsigned int *arg3 = 0 ;
86300   unsigned int temp3 ;
86301
86302   arg1 = (std::vector< unsigned int > *)jarg1;
86303   arg2 = (int)jarg2;
86304   temp3 = (unsigned int)jarg3;
86305   arg3 = &temp3;
86306   {
86307     try {
86308       try {
86309         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86310       }
86311       catch(std::out_of_range &_e) {
86312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86313         return ;
86314       }
86315
86316     } catch (std::out_of_range& e) {
86317       {
86318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86319       };
86320     } catch (std::exception& e) {
86321       {
86322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86323       };
86324     } catch (...) {
86325       {
86326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86327       };
86328     }
86329   }
86330 }
86331
86332
86333 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86334   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86335   std::vector< unsigned int > *arg2 = 0 ;
86336
86337   arg1 = (std::vector< unsigned int > *)jarg1;
86338   arg2 = (std::vector< unsigned int > *)jarg2;
86339   if (!arg2) {
86340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86341     return ;
86342   }
86343   {
86344     try {
86345       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86346     } catch (std::out_of_range& e) {
86347       {
86348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86349       };
86350     } catch (std::exception& e) {
86351       {
86352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86353       };
86354     } catch (...) {
86355       {
86356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86357       };
86358     }
86359   }
86360 }
86361
86362
86363 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86364   void * jresult ;
86365   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86366   int arg2 ;
86367   int arg3 ;
86368   std::vector< unsigned int > *result = 0 ;
86369
86370   arg1 = (std::vector< unsigned int > *)jarg1;
86371   arg2 = (int)jarg2;
86372   arg3 = (int)jarg3;
86373   {
86374     try {
86375       try {
86376         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86377       }
86378       catch(std::out_of_range &_e) {
86379         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86380         return 0;
86381       }
86382       catch(std::invalid_argument &_e) {
86383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86384         return 0;
86385       }
86386
86387     } catch (std::out_of_range& e) {
86388       {
86389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (std::exception& e) {
86392       {
86393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86394       };
86395     } catch (...) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86398       };
86399     }
86400   }
86401   jresult = (void *)result;
86402   return jresult;
86403 }
86404
86405
86406 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86407   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86408   int arg2 ;
86409   unsigned int *arg3 = 0 ;
86410   unsigned int temp3 ;
86411
86412   arg1 = (std::vector< unsigned int > *)jarg1;
86413   arg2 = (int)jarg2;
86414   temp3 = (unsigned int)jarg3;
86415   arg3 = &temp3;
86416   {
86417     try {
86418       try {
86419         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86420       }
86421       catch(std::out_of_range &_e) {
86422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86423         return ;
86424       }
86425
86426     } catch (std::out_of_range& e) {
86427       {
86428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86429       };
86430     } catch (std::exception& e) {
86431       {
86432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86433       };
86434     } catch (...) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86437       };
86438     }
86439   }
86440 }
86441
86442
86443 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86444   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86445   int arg2 ;
86446   std::vector< unsigned int > *arg3 = 0 ;
86447
86448   arg1 = (std::vector< unsigned int > *)jarg1;
86449   arg2 = (int)jarg2;
86450   arg3 = (std::vector< unsigned int > *)jarg3;
86451   if (!arg3) {
86452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86453     return ;
86454   }
86455   {
86456     try {
86457       try {
86458         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86459       }
86460       catch(std::out_of_range &_e) {
86461         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86462         return ;
86463       }
86464
86465     } catch (std::out_of_range& e) {
86466       {
86467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86468       };
86469     } catch (std::exception& e) {
86470       {
86471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86472       };
86473     } catch (...) {
86474       {
86475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86476       };
86477     }
86478   }
86479 }
86480
86481
86482 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86483   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86484   int arg2 ;
86485
86486   arg1 = (std::vector< unsigned int > *)jarg1;
86487   arg2 = (int)jarg2;
86488   {
86489     try {
86490       try {
86491         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86492       }
86493       catch(std::out_of_range &_e) {
86494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86495         return ;
86496       }
86497
86498     } catch (std::out_of_range& e) {
86499       {
86500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86501       };
86502     } catch (std::exception& e) {
86503       {
86504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86505       };
86506     } catch (...) {
86507       {
86508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86509       };
86510     }
86511   }
86512 }
86513
86514
86515 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86516   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86517   int arg2 ;
86518   int arg3 ;
86519
86520   arg1 = (std::vector< unsigned int > *)jarg1;
86521   arg2 = (int)jarg2;
86522   arg3 = (int)jarg3;
86523   {
86524     try {
86525       try {
86526         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86527       }
86528       catch(std::out_of_range &_e) {
86529         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86530         return ;
86531       }
86532       catch(std::invalid_argument &_e) {
86533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86534         return ;
86535       }
86536
86537     } catch (std::out_of_range& e) {
86538       {
86539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86540       };
86541     } catch (std::exception& e) {
86542       {
86543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86544       };
86545     } catch (...) {
86546       {
86547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86548       };
86549     }
86550   }
86551 }
86552
86553
86554 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86555   void * jresult ;
86556   unsigned int *arg1 = 0 ;
86557   int arg2 ;
86558   unsigned int temp1 ;
86559   std::vector< unsigned int > *result = 0 ;
86560
86561   temp1 = (unsigned int)jarg1;
86562   arg1 = &temp1;
86563   arg2 = (int)jarg2;
86564   {
86565     try {
86566       try {
86567         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86568       }
86569       catch(std::out_of_range &_e) {
86570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86571         return 0;
86572       }
86573
86574     } catch (std::out_of_range& e) {
86575       {
86576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86577       };
86578     } catch (std::exception& e) {
86579       {
86580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86581       };
86582     } catch (...) {
86583       {
86584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86585       };
86586     }
86587   }
86588   jresult = (void *)result;
86589   return jresult;
86590 }
86591
86592
86593 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86594   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86595
86596   arg1 = (std::vector< unsigned int > *)jarg1;
86597   {
86598     try {
86599       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86600     } catch (std::out_of_range& e) {
86601       {
86602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86603       };
86604     } catch (std::exception& e) {
86605       {
86606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86607       };
86608     } catch (...) {
86609       {
86610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86611       };
86612     }
86613   }
86614 }
86615
86616
86617 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86618   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86619   int arg2 ;
86620   int arg3 ;
86621
86622   arg1 = (std::vector< unsigned int > *)jarg1;
86623   arg2 = (int)jarg2;
86624   arg3 = (int)jarg3;
86625   {
86626     try {
86627       try {
86628         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86629       }
86630       catch(std::out_of_range &_e) {
86631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86632         return ;
86633       }
86634       catch(std::invalid_argument &_e) {
86635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86636         return ;
86637       }
86638
86639     } catch (std::out_of_range& e) {
86640       {
86641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86642       };
86643     } catch (std::exception& e) {
86644       {
86645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86646       };
86647     } catch (...) {
86648       {
86649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86650       };
86651     }
86652   }
86653 }
86654
86655
86656 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86657   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86658   int arg2 ;
86659   std::vector< unsigned int > *arg3 = 0 ;
86660
86661   arg1 = (std::vector< unsigned int > *)jarg1;
86662   arg2 = (int)jarg2;
86663   arg3 = (std::vector< unsigned int > *)jarg3;
86664   if (!arg3) {
86665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86666     return ;
86667   }
86668   {
86669     try {
86670       try {
86671         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86672       }
86673       catch(std::out_of_range &_e) {
86674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86675         return ;
86676       }
86677
86678     } catch (std::out_of_range& e) {
86679       {
86680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86681       };
86682     } catch (std::exception& e) {
86683       {
86684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86685       };
86686     } catch (...) {
86687       {
86688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86689       };
86690     }
86691   }
86692 }
86693
86694
86695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86696   unsigned int jresult ;
86697   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86698   unsigned int *arg2 = 0 ;
86699   unsigned int temp2 ;
86700   bool result;
86701
86702   arg1 = (std::vector< unsigned int > *)jarg1;
86703   temp2 = (unsigned int)jarg2;
86704   arg2 = &temp2;
86705   {
86706     try {
86707       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86708     } catch (std::out_of_range& e) {
86709       {
86710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86711       };
86712     } catch (std::exception& e) {
86713       {
86714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86715       };
86716     } catch (...) {
86717       {
86718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86719       };
86720     }
86721   }
86722   jresult = result;
86723   return jresult;
86724 }
86725
86726
86727 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86728   int jresult ;
86729   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86730   unsigned int *arg2 = 0 ;
86731   unsigned int temp2 ;
86732   int result;
86733
86734   arg1 = (std::vector< unsigned int > *)jarg1;
86735   temp2 = (unsigned int)jarg2;
86736   arg2 = &temp2;
86737   {
86738     try {
86739       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86740     } catch (std::out_of_range& e) {
86741       {
86742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86743       };
86744     } catch (std::exception& e) {
86745       {
86746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86747       };
86748     } catch (...) {
86749       {
86750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86751       };
86752     }
86753   }
86754   jresult = result;
86755   return jresult;
86756 }
86757
86758
86759 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86760   int jresult ;
86761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86762   unsigned int *arg2 = 0 ;
86763   unsigned int temp2 ;
86764   int result;
86765
86766   arg1 = (std::vector< unsigned int > *)jarg1;
86767   temp2 = (unsigned int)jarg2;
86768   arg2 = &temp2;
86769   {
86770     try {
86771       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86772     } catch (std::out_of_range& e) {
86773       {
86774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (std::exception& e) {
86777       {
86778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786   jresult = result;
86787   return jresult;
86788 }
86789
86790
86791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86792   unsigned int jresult ;
86793   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86794   unsigned int *arg2 = 0 ;
86795   unsigned int temp2 ;
86796   bool result;
86797
86798   arg1 = (std::vector< unsigned int > *)jarg1;
86799   temp2 = (unsigned int)jarg2;
86800   arg2 = &temp2;
86801   {
86802     try {
86803       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86804     } catch (std::out_of_range& e) {
86805       {
86806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86807       };
86808     } catch (std::exception& e) {
86809       {
86810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86811       };
86812     } catch (...) {
86813       {
86814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86815       };
86816     }
86817   }
86818   jresult = result;
86819   return jresult;
86820 }
86821
86822
86823 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemIdContainer(void * jarg1) {
86824   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86825
86826   arg1 = (std::vector< unsigned int > *)jarg1;
86827   {
86828     try {
86829       delete arg1;
86830     } catch (std::out_of_range& e) {
86831       {
86832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86833       };
86834     } catch (std::exception& e) {
86835       {
86836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (...) {
86839       {
86840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86841       };
86842     }
86843   }
86844 }
86845
86846
86847 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_0() {
86848   void * jresult ;
86849   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86850
86851   {
86852     try {
86853       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86854     } catch (std::out_of_range& e) {
86855       {
86856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (std::exception& e) {
86859       {
86860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86865       };
86866     }
86867   }
86868   jresult = (void *)result;
86869   return jresult;
86870 }
86871
86872
86873 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86874   void * jresult ;
86875   unsigned int arg1 ;
86876   Dali::Actor arg2 ;
86877   Dali::Actor *argp2 ;
86878   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86879
86880   arg1 = (unsigned int)jarg1;
86881   argp2 = (Dali::Actor *)jarg2;
86882   if (!argp2) {
86883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86884     return 0;
86885   }
86886   arg2 = *argp2;
86887   {
86888     try {
86889       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86890     } catch (std::out_of_range& e) {
86891       {
86892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86893       };
86894     } catch (std::exception& e) {
86895       {
86896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86897       };
86898     } catch (...) {
86899       {
86900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86901       };
86902     }
86903   }
86904   jresult = (void *)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_Item__SWIG_2(void * jarg1) {
86910   void * jresult ;
86911   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86912   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86913
86914   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86915   if (!arg1) {
86916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86917     return 0;
86918   }
86919   {
86920     try {
86921       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86922     } catch (std::out_of_range& e) {
86923       {
86924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86925       };
86926     } catch (std::exception& e) {
86927       {
86928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86929       };
86930     } catch (...) {
86931       {
86932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86933       };
86934     }
86935   }
86936   jresult = (void *)result;
86937   return jresult;
86938 }
86939
86940
86941 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Item_first_set(void * jarg1, unsigned int jarg2) {
86942   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86943   unsigned int arg2 ;
86944
86945   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86946   arg2 = (unsigned int)jarg2;
86947   if (arg1) (arg1)->first = arg2;
86948 }
86949
86950
86951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_Item_first_get(void * jarg1) {
86952   unsigned int jresult ;
86953   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86954   unsigned int result;
86955
86956   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86957   result = (unsigned int) ((arg1)->first);
86958   jresult = result;
86959   return jresult;
86960 }
86961
86962
86963 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_Item_second_set(void * jarg1, void * jarg2) {
86964   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86965   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86966
86967   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86968   arg2 = (Dali::Actor *)jarg2;
86969   if (arg1) (arg1)->second = *arg2;
86970 }
86971
86972
86973 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_Item_second_get(void * jarg1) {
86974   void * jresult ;
86975   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86976   Dali::Actor *result = 0 ;
86977
86978   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86979   result = (Dali::Actor *)& ((arg1)->second);
86980   jresult = (void *)result;
86981   return jresult;
86982 }
86983
86984
86985 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_Item(void * jarg1) {
86986   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86987
86988   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86989   {
86990     try {
86991       delete arg1;
86992     } catch (std::out_of_range& e) {
86993       {
86994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86995       };
86996     } catch (std::exception& e) {
86997       {
86998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86999       };
87000     } catch (...) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87003       };
87004     }
87005   }
87006 }
87007
87008
87009 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Clear(void * jarg1) {
87010   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87011
87012   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87013   {
87014     try {
87015       (arg1)->clear();
87016     } catch (std::out_of_range& e) {
87017       {
87018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87019       };
87020     } catch (std::exception& e) {
87021       {
87022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87023       };
87024     } catch (...) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87027       };
87028     }
87029   }
87030 }
87031
87032
87033 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Add(void * jarg1, void * jarg2) {
87034   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87035   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87036
87037   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87038   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87039   if (!arg2) {
87040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87041     return ;
87042   }
87043   {
87044     try {
87045       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87046     } catch (std::out_of_range& e) {
87047       {
87048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87049       };
87050     } catch (std::exception& e) {
87051       {
87052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87053       };
87054     } catch (...) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87057       };
87058     }
87059   }
87060 }
87061
87062
87063 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemContainer_size(void * jarg1) {
87064   unsigned long jresult ;
87065   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87066   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87067
87068   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87069   {
87070     try {
87071       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87072     } catch (std::out_of_range& e) {
87073       {
87074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87075       };
87076     } catch (std::exception& e) {
87077       {
87078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87079       };
87080     } catch (...) {
87081       {
87082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87083       };
87084     }
87085   }
87086   jresult = (unsigned long)result;
87087   return jresult;
87088 }
87089
87090
87091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ItemContainer_capacity(void * jarg1) {
87092   unsigned long jresult ;
87093   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87094   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87095
87096   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87097   {
87098     try {
87099       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87100     } catch (std::out_of_range& e) {
87101       {
87102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (std::exception& e) {
87105       {
87106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (...) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87111       };
87112     }
87113   }
87114   jresult = (unsigned long)result;
87115   return jresult;
87116 }
87117
87118
87119 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87120   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87121   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87122
87123   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87124   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87125   {
87126     try {
87127       (arg1)->reserve(arg2);
87128     } catch (std::out_of_range& e) {
87129       {
87130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87131       };
87132     } catch (std::exception& e) {
87133       {
87134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87139       };
87140     }
87141   }
87142 }
87143
87144
87145 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_0() {
87146   void * jresult ;
87147   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87148
87149   {
87150     try {
87151       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87152     } catch (std::out_of_range& e) {
87153       {
87154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87155       };
87156     } catch (std::exception& e) {
87157       {
87158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87159       };
87160     } catch (...) {
87161       {
87162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87163       };
87164     }
87165   }
87166   jresult = (void *)result;
87167   return jresult;
87168 }
87169
87170
87171 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_1(void * jarg1) {
87172   void * jresult ;
87173   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87174   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87175
87176   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87177   if (!arg1) {
87178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87179     return 0;
87180   }
87181   {
87182     try {
87183       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);
87184     } catch (std::out_of_range& e) {
87185       {
87186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87187       };
87188     } catch (std::exception& e) {
87189       {
87190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87191       };
87192     } catch (...) {
87193       {
87194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87195       };
87196     }
87197   }
87198   jresult = (void *)result;
87199   return jresult;
87200 }
87201
87202
87203 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ItemContainer__SWIG_2(int jarg1) {
87204   void * jresult ;
87205   int arg1 ;
87206   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87207
87208   arg1 = (int)jarg1;
87209   {
87210     try {
87211       try {
87212         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);
87213       }
87214       catch(std::out_of_range &_e) {
87215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87216         return 0;
87217       }
87218
87219     } catch (std::out_of_range& e) {
87220       {
87221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87222       };
87223     } catch (std::exception& e) {
87224       {
87225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87226       };
87227     } catch (...) {
87228       {
87229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87230       };
87231     }
87232   }
87233   jresult = (void *)result;
87234   return jresult;
87235 }
87236
87237
87238 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87239   void * jresult ;
87240   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87241   int arg2 ;
87242   std::pair< unsigned int,Dali::Actor > result;
87243
87244   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87245   arg2 = (int)jarg2;
87246   {
87247     try {
87248       try {
87249         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87250       }
87251       catch(std::out_of_range &_e) {
87252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87253         return 0;
87254       }
87255
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (...) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87267       };
87268     }
87269   }
87270   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87271   return jresult;
87272 }
87273
87274
87275 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_getitem(void * jarg1, int jarg2) {
87276   void * jresult ;
87277   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87278   int arg2 ;
87279   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87280
87281   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87282   arg2 = (int)jarg2;
87283   {
87284     try {
87285       try {
87286         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87287       }
87288       catch(std::out_of_range &_e) {
87289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87290         return 0;
87291       }
87292
87293     } catch (std::out_of_range& e) {
87294       {
87295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87296       };
87297     } catch (std::exception& e) {
87298       {
87299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87300       };
87301     } catch (...) {
87302       {
87303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87304       };
87305     }
87306   }
87307   jresult = (void *)result;
87308   return jresult;
87309 }
87310
87311
87312 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87313   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87314   int arg2 ;
87315   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87316
87317   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87318   arg2 = (int)jarg2;
87319   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87320   if (!arg3) {
87321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87322     return ;
87323   }
87324   {
87325     try {
87326       try {
87327         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);
87328       }
87329       catch(std::out_of_range &_e) {
87330         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87331         return ;
87332       }
87333
87334     } catch (std::out_of_range& e) {
87335       {
87336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (std::exception& e) {
87339       {
87340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87341       };
87342     } catch (...) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87345       };
87346     }
87347   }
87348 }
87349
87350
87351 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87352   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87353   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87354
87355   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87356   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87357   if (!arg2) {
87358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87359     return ;
87360   }
87361   {
87362     try {
87363       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);
87364     } catch (std::out_of_range& e) {
87365       {
87366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87367       };
87368     } catch (std::exception& e) {
87369       {
87370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87371       };
87372     } catch (...) {
87373       {
87374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87375       };
87376     }
87377   }
87378 }
87379
87380
87381 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87382   void * jresult ;
87383   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87384   int arg2 ;
87385   int arg3 ;
87386   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87387
87388   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87389   arg2 = (int)jarg2;
87390   arg3 = (int)jarg3;
87391   {
87392     try {
87393       try {
87394         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);
87395       }
87396       catch(std::out_of_range &_e) {
87397         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87398         return 0;
87399       }
87400       catch(std::invalid_argument &_e) {
87401         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87402         return 0;
87403       }
87404
87405     } catch (std::out_of_range& e) {
87406       {
87407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87408       };
87409     } catch (std::exception& e) {
87410       {
87411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87412       };
87413     } catch (...) {
87414       {
87415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87416       };
87417     }
87418   }
87419   jresult = (void *)result;
87420   return jresult;
87421 }
87422
87423
87424 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87425   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87426   int arg2 ;
87427   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87428
87429   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87430   arg2 = (int)jarg2;
87431   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87432   if (!arg3) {
87433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87434     return ;
87435   }
87436   {
87437     try {
87438       try {
87439         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);
87440       }
87441       catch(std::out_of_range &_e) {
87442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87443         return ;
87444       }
87445
87446     } catch (std::out_of_range& e) {
87447       {
87448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87449       };
87450     } catch (std::exception& e) {
87451       {
87452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87453       };
87454     } catch (...) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87457       };
87458     }
87459   }
87460 }
87461
87462
87463 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87464   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87465   int arg2 ;
87466   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87467
87468   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87469   arg2 = (int)jarg2;
87470   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87471   if (!arg3) {
87472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87473     return ;
87474   }
87475   {
87476     try {
87477       try {
87478         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);
87479       }
87480       catch(std::out_of_range &_e) {
87481         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87482         return ;
87483       }
87484
87485     } catch (std::out_of_range& e) {
87486       {
87487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87488       };
87489     } catch (std::exception& e) {
87490       {
87491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87492       };
87493     } catch (...) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87496       };
87497     }
87498   }
87499 }
87500
87501
87502 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87503   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87504   int arg2 ;
87505
87506   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87507   arg2 = (int)jarg2;
87508   {
87509     try {
87510       try {
87511         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87512       }
87513       catch(std::out_of_range &_e) {
87514         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87515         return ;
87516       }
87517
87518     } catch (std::out_of_range& e) {
87519       {
87520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87521       };
87522     } catch (std::exception& e) {
87523       {
87524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87529       };
87530     }
87531   }
87532 }
87533
87534
87535 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87536   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87537   int arg2 ;
87538   int arg3 ;
87539
87540   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87541   arg2 = (int)jarg2;
87542   arg3 = (int)jarg3;
87543   {
87544     try {
87545       try {
87546         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87547       }
87548       catch(std::out_of_range &_e) {
87549         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87550         return ;
87551       }
87552       catch(std::invalid_argument &_e) {
87553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87554         return ;
87555       }
87556
87557     } catch (std::out_of_range& e) {
87558       {
87559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87560       };
87561     } catch (std::exception& e) {
87562       {
87563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87564       };
87565     } catch (...) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87568       };
87569     }
87570   }
87571 }
87572
87573
87574 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ItemContainer_Repeat(void * jarg1, int jarg2) {
87575   void * jresult ;
87576   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87577   int arg2 ;
87578   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87579
87580   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87581   if (!arg1) {
87582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87583     return 0;
87584   }
87585   arg2 = (int)jarg2;
87586   {
87587     try {
87588       try {
87589         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);
87590       }
87591       catch(std::out_of_range &_e) {
87592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87593         return 0;
87594       }
87595
87596     } catch (std::out_of_range& e) {
87597       {
87598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87599       };
87600     } catch (std::exception& e) {
87601       {
87602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87603       };
87604     } catch (...) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87607       };
87608     }
87609   }
87610   jresult = (void *)result;
87611   return jresult;
87612 }
87613
87614
87615 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87616   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87617
87618   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87619   {
87620     try {
87621       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87622     } catch (std::out_of_range& e) {
87623       {
87624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87625       };
87626     } catch (std::exception& e) {
87627       {
87628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87629       };
87630     } catch (...) {
87631       {
87632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87633       };
87634     }
87635   }
87636 }
87637
87638
87639 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87640   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87641   int arg2 ;
87642   int arg3 ;
87643
87644   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87645   arg2 = (int)jarg2;
87646   arg3 = (int)jarg3;
87647   {
87648     try {
87649       try {
87650         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87651       }
87652       catch(std::out_of_range &_e) {
87653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87654         return ;
87655       }
87656       catch(std::invalid_argument &_e) {
87657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87658         return ;
87659       }
87660
87661     } catch (std::out_of_range& e) {
87662       {
87663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87664       };
87665     } catch (std::exception& e) {
87666       {
87667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87668       };
87669     } catch (...) {
87670       {
87671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87672       };
87673     }
87674   }
87675 }
87676
87677
87678 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87679   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87680   int arg2 ;
87681   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87682
87683   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87684   arg2 = (int)jarg2;
87685   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87686   if (!arg3) {
87687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87688     return ;
87689   }
87690   {
87691     try {
87692       try {
87693         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);
87694       }
87695       catch(std::out_of_range &_e) {
87696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87697         return ;
87698       }
87699
87700     } catch (std::out_of_range& e) {
87701       {
87702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87703       };
87704     } catch (std::exception& e) {
87705       {
87706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87707       };
87708     } catch (...) {
87709       {
87710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87711       };
87712     }
87713   }
87714 }
87715
87716
87717 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ItemContainer(void * jarg1) {
87718   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87719
87720   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87721   {
87722     try {
87723       delete arg1;
87724     } catch (std::out_of_range& e) {
87725       {
87726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87727       };
87728     } catch (std::exception& e) {
87729       {
87730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87731       };
87732     } catch (...) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87735       };
87736     }
87737   }
87738 }
87739
87740
87741 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Clear(void * jarg1) {
87742   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87743
87744   arg1 = (std::vector< Dali::Actor > *)jarg1;
87745   {
87746     try {
87747       (arg1)->clear();
87748     } catch (std::out_of_range& e) {
87749       {
87750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87751       };
87752     } catch (std::exception& e) {
87753       {
87754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87755       };
87756     } catch (...) {
87757       {
87758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87759       };
87760     }
87761   }
87762 }
87763
87764
87765 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Add(void * jarg1, void * jarg2) {
87766   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87767   Dali::Actor *arg2 = 0 ;
87768
87769   arg1 = (std::vector< Dali::Actor > *)jarg1;
87770   arg2 = (Dali::Actor *)jarg2;
87771   if (!arg2) {
87772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87773     return ;
87774   }
87775   {
87776     try {
87777       (arg1)->push_back((Dali::Actor const &)*arg2);
87778     } catch (std::out_of_range& e) {
87779       {
87780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87781       };
87782     } catch (std::exception& e) {
87783       {
87784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87785       };
87786     } catch (...) {
87787       {
87788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87789       };
87790     }
87791   }
87792 }
87793
87794
87795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorContainer_size(void * jarg1) {
87796   unsigned long jresult ;
87797   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87798   std::vector< Dali::Actor >::size_type result;
87799
87800   arg1 = (std::vector< Dali::Actor > *)jarg1;
87801   {
87802     try {
87803       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87804     } catch (std::out_of_range& e) {
87805       {
87806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87807       };
87808     } catch (std::exception& e) {
87809       {
87810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87811       };
87812     } catch (...) {
87813       {
87814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87815       };
87816     }
87817   }
87818   jresult = (unsigned long)result;
87819   return jresult;
87820 }
87821
87822
87823 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ActorContainer_capacity(void * jarg1) {
87824   unsigned long jresult ;
87825   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87826   std::vector< Dali::Actor >::size_type result;
87827
87828   arg1 = (std::vector< Dali::Actor > *)jarg1;
87829   {
87830     try {
87831       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87832     } catch (std::out_of_range& e) {
87833       {
87834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87835       };
87836     } catch (std::exception& e) {
87837       {
87838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87839       };
87840     } catch (...) {
87841       {
87842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87843       };
87844     }
87845   }
87846   jresult = (unsigned long)result;
87847   return jresult;
87848 }
87849
87850
87851 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87852   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87853   std::vector< Dali::Actor >::size_type arg2 ;
87854
87855   arg1 = (std::vector< Dali::Actor > *)jarg1;
87856   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87857   {
87858     try {
87859       (arg1)->reserve(arg2);
87860     } catch (std::out_of_range& e) {
87861       {
87862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87863       };
87864     } catch (std::exception& e) {
87865       {
87866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87867       };
87868     } catch (...) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87871       };
87872     }
87873   }
87874 }
87875
87876
87877 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_0() {
87878   void * jresult ;
87879   std::vector< Dali::Actor > *result = 0 ;
87880
87881   {
87882     try {
87883       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87884     } catch (std::out_of_range& e) {
87885       {
87886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87887       };
87888     } catch (std::exception& e) {
87889       {
87890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87891       };
87892     } catch (...) {
87893       {
87894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87895       };
87896     }
87897   }
87898   jresult = (void *)result;
87899   return jresult;
87900 }
87901
87902
87903 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_1(void * jarg1) {
87904   void * jresult ;
87905   std::vector< Dali::Actor > *arg1 = 0 ;
87906   std::vector< Dali::Actor > *result = 0 ;
87907
87908   arg1 = (std::vector< Dali::Actor > *)jarg1;
87909   if (!arg1) {
87910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87911     return 0;
87912   }
87913   {
87914     try {
87915       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87916     } catch (std::out_of_range& e) {
87917       {
87918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87919       };
87920     } catch (std::exception& e) {
87921       {
87922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87923       };
87924     } catch (...) {
87925       {
87926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87927       };
87928     }
87929   }
87930   jresult = (void *)result;
87931   return jresult;
87932 }
87933
87934
87935 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ActorContainer__SWIG_2(int jarg1) {
87936   void * jresult ;
87937   int arg1 ;
87938   std::vector< Dali::Actor > *result = 0 ;
87939
87940   arg1 = (int)jarg1;
87941   {
87942     try {
87943       try {
87944         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87945       }
87946       catch(std::out_of_range &_e) {
87947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87948         return 0;
87949       }
87950
87951     } catch (std::out_of_range& e) {
87952       {
87953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87954       };
87955     } catch (std::exception& e) {
87956       {
87957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87958       };
87959     } catch (...) {
87960       {
87961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87962       };
87963     }
87964   }
87965   jresult = (void *)result;
87966   return jresult;
87967 }
87968
87969
87970 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87971   void * jresult ;
87972   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87973   int arg2 ;
87974   Dali::Actor result;
87975
87976   arg1 = (std::vector< Dali::Actor > *)jarg1;
87977   arg2 = (int)jarg2;
87978   {
87979     try {
87980       try {
87981         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87982       }
87983       catch(std::out_of_range &_e) {
87984         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87985         return 0;
87986       }
87987
87988     } catch (std::out_of_range& e) {
87989       {
87990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (std::exception& e) {
87993       {
87994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87995       };
87996     } catch (...) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87999       };
88000     }
88001   }
88002   jresult = new Dali::Actor((const Dali::Actor &)result);
88003   return jresult;
88004 }
88005
88006
88007 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_getitem(void * jarg1, int jarg2) {
88008   void * jresult ;
88009   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88010   int arg2 ;
88011   Dali::Actor *result = 0 ;
88012
88013   arg1 = (std::vector< Dali::Actor > *)jarg1;
88014   arg2 = (int)jarg2;
88015   {
88016     try {
88017       try {
88018         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88019       }
88020       catch(std::out_of_range &_e) {
88021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88022         return 0;
88023       }
88024
88025     } catch (std::out_of_range& e) {
88026       {
88027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88028       };
88029     } catch (std::exception& e) {
88030       {
88031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88032       };
88033     } catch (...) {
88034       {
88035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88036       };
88037     }
88038   }
88039   jresult = (void *)result;
88040   return jresult;
88041 }
88042
88043
88044 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88045   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88046   int arg2 ;
88047   Dali::Actor *arg3 = 0 ;
88048
88049   arg1 = (std::vector< Dali::Actor > *)jarg1;
88050   arg2 = (int)jarg2;
88051   arg3 = (Dali::Actor *)jarg3;
88052   if (!arg3) {
88053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88054     return ;
88055   }
88056   {
88057     try {
88058       try {
88059         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88060       }
88061       catch(std::out_of_range &_e) {
88062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88063         return ;
88064       }
88065
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88073       };
88074     } catch (...) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88077       };
88078     }
88079   }
88080 }
88081
88082
88083 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88084   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88085   std::vector< Dali::Actor > *arg2 = 0 ;
88086
88087   arg1 = (std::vector< Dali::Actor > *)jarg1;
88088   arg2 = (std::vector< Dali::Actor > *)jarg2;
88089   if (!arg2) {
88090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88091     return ;
88092   }
88093   {
88094     try {
88095       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88096     } catch (std::out_of_range& e) {
88097       {
88098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88099       };
88100     } catch (std::exception& e) {
88101       {
88102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88103       };
88104     } catch (...) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88107       };
88108     }
88109   }
88110 }
88111
88112
88113 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88114   void * jresult ;
88115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88116   int arg2 ;
88117   int arg3 ;
88118   std::vector< Dali::Actor > *result = 0 ;
88119
88120   arg1 = (std::vector< Dali::Actor > *)jarg1;
88121   arg2 = (int)jarg2;
88122   arg3 = (int)jarg3;
88123   {
88124     try {
88125       try {
88126         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88127       }
88128       catch(std::out_of_range &_e) {
88129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88130         return 0;
88131       }
88132       catch(std::invalid_argument &_e) {
88133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88134         return 0;
88135       }
88136
88137     } catch (std::out_of_range& e) {
88138       {
88139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88140       };
88141     } catch (std::exception& e) {
88142       {
88143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88144       };
88145     } catch (...) {
88146       {
88147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88148       };
88149     }
88150   }
88151   jresult = (void *)result;
88152   return jresult;
88153 }
88154
88155
88156 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88157   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88158   int arg2 ;
88159   Dali::Actor *arg3 = 0 ;
88160
88161   arg1 = (std::vector< Dali::Actor > *)jarg1;
88162   arg2 = (int)jarg2;
88163   arg3 = (Dali::Actor *)jarg3;
88164   if (!arg3) {
88165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88166     return ;
88167   }
88168   {
88169     try {
88170       try {
88171         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88172       }
88173       catch(std::out_of_range &_e) {
88174         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88175         return ;
88176       }
88177
88178     } catch (std::out_of_range& e) {
88179       {
88180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88181       };
88182     } catch (std::exception& e) {
88183       {
88184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88185       };
88186     } catch (...) {
88187       {
88188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88189       };
88190     }
88191   }
88192 }
88193
88194
88195 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88196   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88197   int arg2 ;
88198   std::vector< Dali::Actor > *arg3 = 0 ;
88199
88200   arg1 = (std::vector< Dali::Actor > *)jarg1;
88201   arg2 = (int)jarg2;
88202   arg3 = (std::vector< Dali::Actor > *)jarg3;
88203   if (!arg3) {
88204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88205     return ;
88206   }
88207   {
88208     try {
88209       try {
88210         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88211       }
88212       catch(std::out_of_range &_e) {
88213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88214         return ;
88215       }
88216
88217     } catch (std::out_of_range& e) {
88218       {
88219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88220       };
88221     } catch (std::exception& e) {
88222       {
88223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88224       };
88225     } catch (...) {
88226       {
88227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88228       };
88229     }
88230   }
88231 }
88232
88233
88234 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88235   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88236   int arg2 ;
88237
88238   arg1 = (std::vector< Dali::Actor > *)jarg1;
88239   arg2 = (int)jarg2;
88240   {
88241     try {
88242       try {
88243         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88244       }
88245       catch(std::out_of_range &_e) {
88246         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88247         return ;
88248       }
88249
88250     } catch (std::out_of_range& e) {
88251       {
88252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88253       };
88254     } catch (std::exception& e) {
88255       {
88256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88257       };
88258     } catch (...) {
88259       {
88260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88261       };
88262     }
88263   }
88264 }
88265
88266
88267 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88268   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88269   int arg2 ;
88270   int arg3 ;
88271
88272   arg1 = (std::vector< Dali::Actor > *)jarg1;
88273   arg2 = (int)jarg2;
88274   arg3 = (int)jarg3;
88275   {
88276     try {
88277       try {
88278         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88279       }
88280       catch(std::out_of_range &_e) {
88281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88282         return ;
88283       }
88284       catch(std::invalid_argument &_e) {
88285         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88286         return ;
88287       }
88288
88289     } catch (std::out_of_range& e) {
88290       {
88291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88292       };
88293     } catch (std::exception& e) {
88294       {
88295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88296       };
88297     } catch (...) {
88298       {
88299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88300       };
88301     }
88302   }
88303 }
88304
88305
88306 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_ActorContainer_Repeat(void * jarg1, int jarg2) {
88307   void * jresult ;
88308   Dali::Actor *arg1 = 0 ;
88309   int arg2 ;
88310   std::vector< Dali::Actor > *result = 0 ;
88311
88312   arg1 = (Dali::Actor *)jarg1;
88313   if (!arg1) {
88314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88315     return 0;
88316   }
88317   arg2 = (int)jarg2;
88318   {
88319     try {
88320       try {
88321         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88322       }
88323       catch(std::out_of_range &_e) {
88324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88325         return 0;
88326       }
88327
88328     } catch (std::out_of_range& e) {
88329       {
88330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88331       };
88332     } catch (std::exception& e) {
88333       {
88334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88335       };
88336     } catch (...) {
88337       {
88338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88339       };
88340     }
88341   }
88342   jresult = (void *)result;
88343   return jresult;
88344 }
88345
88346
88347 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88348   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88349
88350   arg1 = (std::vector< Dali::Actor > *)jarg1;
88351   {
88352     try {
88353       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88354     } catch (std::out_of_range& e) {
88355       {
88356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88357       };
88358     } catch (std::exception& e) {
88359       {
88360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88361       };
88362     } catch (...) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88365       };
88366     }
88367   }
88368 }
88369
88370
88371 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88372   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88373   int arg2 ;
88374   int arg3 ;
88375
88376   arg1 = (std::vector< Dali::Actor > *)jarg1;
88377   arg2 = (int)jarg2;
88378   arg3 = (int)jarg3;
88379   {
88380     try {
88381       try {
88382         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88383       }
88384       catch(std::out_of_range &_e) {
88385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88386         return ;
88387       }
88388       catch(std::invalid_argument &_e) {
88389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88390         return ;
88391       }
88392
88393     } catch (std::out_of_range& e) {
88394       {
88395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88396       };
88397     } catch (std::exception& e) {
88398       {
88399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88400       };
88401     } catch (...) {
88402       {
88403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88404       };
88405     }
88406   }
88407 }
88408
88409
88410 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88411   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88412   int arg2 ;
88413   std::vector< Dali::Actor > *arg3 = 0 ;
88414
88415   arg1 = (std::vector< Dali::Actor > *)jarg1;
88416   arg2 = (int)jarg2;
88417   arg3 = (std::vector< Dali::Actor > *)jarg3;
88418   if (!arg3) {
88419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88420     return ;
88421   }
88422   {
88423     try {
88424       try {
88425         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88426       }
88427       catch(std::out_of_range &_e) {
88428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88429         return ;
88430       }
88431
88432     } catch (std::out_of_range& e) {
88433       {
88434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88435       };
88436     } catch (std::exception& e) {
88437       {
88438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88439       };
88440     } catch (...) {
88441       {
88442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88443       };
88444     }
88445   }
88446 }
88447
88448
88449 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ActorContainer(void * jarg1) {
88450   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88451
88452   arg1 = (std::vector< Dali::Actor > *)jarg1;
88453   {
88454     try {
88455       delete arg1;
88456     } catch (std::out_of_range& e) {
88457       {
88458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88459       };
88460     } catch (std::exception& e) {
88461       {
88462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (...) {
88465       {
88466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88467       };
88468     }
88469   }
88470 }
88471
88472
88473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Empty(void * jarg1) {
88474   unsigned int jresult ;
88475   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88476   bool result;
88477
88478   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88479   {
88480     try {
88481       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88482     } catch (std::out_of_range& e) {
88483       {
88484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88485       };
88486     } catch (std::exception& e) {
88487       {
88488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88489       };
88490     } catch (...) {
88491       {
88492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88493       };
88494     }
88495   }
88496   jresult = result;
88497   return jresult;
88498 }
88499
88500
88501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88502   unsigned long jresult ;
88503   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88504   std::size_t result;
88505
88506   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88507   {
88508     try {
88509       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88510     } catch (std::out_of_range& e) {
88511       {
88512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (std::exception& e) {
88515       {
88516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (...) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88521       };
88522     }
88523   }
88524   jresult = (unsigned long)result;
88525   return jresult;
88526 }
88527
88528
88529 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88530   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88531   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88532
88533   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88534   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88535   {
88536     try {
88537       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88538     } catch (std::out_of_range& e) {
88539       {
88540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88541       };
88542     } catch (std::exception& e) {
88543       {
88544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88545       };
88546     } catch (...) {
88547       {
88548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88549       };
88550     }
88551   }
88552 }
88553
88554
88555 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88556   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88557   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88558
88559   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88560   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88561   {
88562     try {
88563       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88564     } catch (std::out_of_range& e) {
88565       {
88566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88567       };
88568     } catch (std::exception& e) {
88569       {
88570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88571       };
88572     } catch (...) {
88573       {
88574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88575       };
88576     }
88577   }
88578 }
88579
88580
88581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88582   unsigned int jresult ;
88583   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88584   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88585   bool result;
88586
88587   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88588   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88589   if (!arg2) {
88590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88591     return 0;
88592   }
88593   {
88594     try {
88595       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88596     } catch (std::out_of_range& e) {
88597       {
88598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88599       };
88600     } catch (std::exception& e) {
88601       {
88602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88603       };
88604     } catch (...) {
88605       {
88606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88607       };
88608     }
88609   }
88610   jresult = result;
88611   return jresult;
88612 }
88613
88614
88615 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityActionSignal() {
88616   void * jresult ;
88617   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88618
88619   {
88620     try {
88621       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88622     } catch (std::out_of_range& e) {
88623       {
88624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (std::exception& e) {
88627       {
88628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (...) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88633       };
88634     }
88635   }
88636   jresult = (void *)result;
88637   return jresult;
88638 }
88639
88640
88641 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityActionSignal(void * jarg1) {
88642   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88643
88644   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88645   {
88646     try {
88647       delete arg1;
88648     } catch (std::out_of_range& e) {
88649       {
88650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (std::exception& e) {
88653       {
88654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662 }
88663
88664
88665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Empty(void * jarg1) {
88666   unsigned int jresult ;
88667   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88668   bool result;
88669
88670   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88671   {
88672     try {
88673       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);
88674     } catch (std::out_of_range& e) {
88675       {
88676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88677       };
88678     } catch (std::exception& e) {
88679       {
88680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88681       };
88682     } catch (...) {
88683       {
88684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88685       };
88686     }
88687   }
88688   jresult = result;
88689   return jresult;
88690 }
88691
88692
88693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_GetConnectionCount(void * jarg1) {
88694   unsigned long jresult ;
88695   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88696   std::size_t result;
88697
88698   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88699   {
88700     try {
88701       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);
88702     } catch (std::out_of_range& e) {
88703       {
88704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88705       };
88706     } catch (std::exception& e) {
88707       {
88708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88713       };
88714     }
88715   }
88716   jresult = (unsigned long)result;
88717   return jresult;
88718 }
88719
88720
88721 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Connect(void * jarg1, void * jarg2) {
88722   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88723   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
88724
88725   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88726   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
88727   {
88728     try {
88729       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
88730     } catch (std::out_of_range& e) {
88731       {
88732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88733       };
88734     } catch (std::exception& e) {
88735       {
88736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88737       };
88738     } catch (...) {
88739       {
88740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88741       };
88742     }
88743   }
88744 }
88745
88746
88747 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Disconnect(void * jarg1, void * jarg2) {
88748   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88749   bool (*arg2)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)) 0 ;
88750
88751   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88752   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &))jarg2;
88753   {
88754     try {
88755       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
88756     } catch (std::out_of_range& e) {
88757       {
88758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88759       };
88760     } catch (std::exception& e) {
88761       {
88762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88763       };
88764     } catch (...) {
88765       {
88766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88767       };
88768     }
88769   }
88770 }
88771
88772
88773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityActionScrollSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88774   unsigned int jresult ;
88775   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88776   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88777   Dali::TouchEvent *arg3 = 0 ;
88778   bool result;
88779
88780   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88781   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88782   if (!arg2) {
88783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88784     return 0;
88785   }
88786   arg3 = (Dali::TouchEvent *)jarg3;
88787   if (!arg3) {
88788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
88789     return 0;
88790   }
88791   {
88792     try {
88793       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);
88794     } catch (std::out_of_range& e) {
88795       {
88796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88797       };
88798     } catch (std::exception& e) {
88799       {
88800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88801       };
88802     } catch (...) {
88803       {
88804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88805       };
88806     }
88807   }
88808   jresult = result;
88809   return jresult;
88810 }
88811
88812
88813 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityActionScrollSignal() {
88814   void * jresult ;
88815   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *result = 0 ;
88816
88817   {
88818     try {
88819       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) >();
88820     } catch (std::out_of_range& e) {
88821       {
88822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88823       };
88824     } catch (std::exception& e) {
88825       {
88826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88827       };
88828     } catch (...) {
88829       {
88830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88831       };
88832     }
88833   }
88834   jresult = (void *)result;
88835   return jresult;
88836 }
88837
88838
88839 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityActionScrollSignal(void * jarg1) {
88840   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *) 0 ;
88841
88842   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *)jarg1;
88843   {
88844     try {
88845       delete arg1;
88846     } catch (std::out_of_range& e) {
88847       {
88848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88849       };
88850     } catch (std::exception& e) {
88851       {
88852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88853       };
88854     } catch (...) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88857       };
88858     }
88859   }
88860 }
88861
88862
88863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88864   unsigned int jresult ;
88865   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88866   bool result;
88867
88868   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88869   {
88870     try {
88871       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);
88872     } catch (std::out_of_range& e) {
88873       {
88874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (std::exception& e) {
88877       {
88878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (...) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88883       };
88884     }
88885   }
88886   jresult = result;
88887   return jresult;
88888 }
88889
88890
88891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88892   unsigned long jresult ;
88893   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88894   std::size_t result;
88895
88896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88897   {
88898     try {
88899       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);
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88907       };
88908     } catch (...) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88911       };
88912     }
88913   }
88914   jresult = (unsigned long)result;
88915   return jresult;
88916 }
88917
88918
88919 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88920   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88921   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88922
88923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88924   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88925   {
88926     try {
88927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88928     } catch (std::out_of_range& e) {
88929       {
88930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88931       };
88932     } catch (std::exception& e) {
88933       {
88934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88935       };
88936     } catch (...) {
88937       {
88938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88939       };
88940     }
88941   }
88942 }
88943
88944
88945 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88946   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88947   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88948
88949   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88950   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88951   {
88952     try {
88953       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88954     } catch (std::out_of_range& e) {
88955       {
88956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88957       };
88958     } catch (std::exception& e) {
88959       {
88960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88961       };
88962     } catch (...) {
88963       {
88964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88965       };
88966     }
88967   }
88968 }
88969
88970
88971 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88972   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88973   Dali::Actor arg2 ;
88974   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88975   Dali::Actor *argp2 ;
88976
88977   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88978   argp2 = (Dali::Actor *)jarg2;
88979   if (!argp2) {
88980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88981     return ;
88982   }
88983   arg2 = *argp2;
88984   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88985   {
88986     try {
88987       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88988     } catch (std::out_of_range& e) {
88989       {
88990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88991       };
88992     } catch (std::exception& e) {
88993       {
88994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88995       };
88996     } catch (...) {
88997       {
88998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88999       };
89000     }
89001   }
89002 }
89003
89004
89005 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_AccessibilityFocusOvershotSignal() {
89006   void * jresult ;
89007   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89008
89009   {
89010     try {
89011       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (...) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89023       };
89024     }
89025   }
89026   jresult = (void *)result;
89027   return jresult;
89028 }
89029
89030
89031 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89032   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89033
89034   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89035   {
89036     try {
89037       delete arg1;
89038     } catch (std::out_of_range& e) {
89039       {
89040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89041       };
89042     } catch (std::exception& e) {
89043       {
89044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89045       };
89046     } catch (...) {
89047       {
89048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89049       };
89050     }
89051   }
89052 }
89053
89054
89055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Empty(void * jarg1) {
89056   unsigned int jresult ;
89057   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89058   bool result;
89059
89060   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89061   {
89062     try {
89063       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89064     } catch (std::out_of_range& e) {
89065       {
89066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89067       };
89068     } catch (std::exception& e) {
89069       {
89070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89071       };
89072     } catch (...) {
89073       {
89074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89075       };
89076     }
89077   }
89078   jresult = result;
89079   return jresult;
89080 }
89081
89082
89083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89084   unsigned long jresult ;
89085   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89086   std::size_t result;
89087
89088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89089   {
89090     try {
89091       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89092     } catch (std::out_of_range& e) {
89093       {
89094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89095       };
89096     } catch (std::exception& e) {
89097       {
89098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89099       };
89100     } catch (...) {
89101       {
89102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89103       };
89104     }
89105   }
89106   jresult = (unsigned long)result;
89107   return jresult;
89108 }
89109
89110
89111 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89112   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89113   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89114
89115   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89116   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89117   {
89118     try {
89119       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89120     } catch (std::out_of_range& e) {
89121       {
89122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89123       };
89124     } catch (std::exception& e) {
89125       {
89126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89127       };
89128     } catch (...) {
89129       {
89130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89131       };
89132     }
89133   }
89134 }
89135
89136
89137 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89138   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89139   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89140
89141   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89142   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89143   {
89144     try {
89145       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89146     } catch (std::out_of_range& e) {
89147       {
89148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89149       };
89150     } catch (std::exception& e) {
89151       {
89152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89153       };
89154     } catch (...) {
89155       {
89156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89157       };
89158     }
89159   }
89160 }
89161
89162
89163 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89164   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89165   Dali::Actor arg2 ;
89166   Dali::Actor arg3 ;
89167   Dali::Actor *argp2 ;
89168   Dali::Actor *argp3 ;
89169
89170   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89171   argp2 = (Dali::Actor *)jarg2;
89172   if (!argp2) {
89173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89174     return ;
89175   }
89176   arg2 = *argp2;
89177   argp3 = (Dali::Actor *)jarg3;
89178   if (!argp3) {
89179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89180     return ;
89181   }
89182   arg3 = *argp3;
89183   {
89184     try {
89185       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89186     } catch (std::out_of_range& e) {
89187       {
89188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89189       };
89190     } catch (std::exception& e) {
89191       {
89192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89193       };
89194     } catch (...) {
89195       {
89196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89197       };
89198     }
89199   }
89200 }
89201
89202
89203 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FocusChangedSignal() {
89204   void * jresult ;
89205   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89206
89207   {
89208     try {
89209       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89210     } catch (std::out_of_range& e) {
89211       {
89212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89213       };
89214     } catch (std::exception& e) {
89215       {
89216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89217       };
89218     } catch (...) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89221       };
89222     }
89223   }
89224   jresult = (void *)result;
89225   return jresult;
89226 }
89227
89228
89229 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FocusChangedSignal(void * jarg1) {
89230   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89231
89232   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89233   {
89234     try {
89235       delete arg1;
89236     } catch (std::out_of_range& e) {
89237       {
89238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89239       };
89240     } catch (std::exception& e) {
89241       {
89242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89243       };
89244     } catch (...) {
89245       {
89246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89247       };
89248     }
89249   }
89250 }
89251
89252
89253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Empty(void * jarg1) {
89254   unsigned int jresult ;
89255   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89256   bool result;
89257
89258   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89259   {
89260     try {
89261       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89262     } catch (std::out_of_range& e) {
89263       {
89264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89265       };
89266     } catch (std::exception& e) {
89267       {
89268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89269       };
89270     } catch (...) {
89271       {
89272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89273       };
89274     }
89275   }
89276   jresult = result;
89277   return jresult;
89278 }
89279
89280
89281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89282   unsigned long jresult ;
89283   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89284   std::size_t result;
89285
89286   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89287   {
89288     try {
89289       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89290     } catch (std::out_of_range& e) {
89291       {
89292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89293       };
89294     } catch (std::exception& e) {
89295       {
89296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89301       };
89302     }
89303   }
89304   jresult = (unsigned long)result;
89305   return jresult;
89306 }
89307
89308
89309 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89310   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89311   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89312
89313   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89314   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89315   {
89316     try {
89317       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89318     } catch (std::out_of_range& e) {
89319       {
89320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89321       };
89322     } catch (std::exception& e) {
89323       {
89324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89325       };
89326     } catch (...) {
89327       {
89328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89329       };
89330     }
89331   }
89332 }
89333
89334
89335 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89336   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89337   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89338
89339   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89340   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89341   {
89342     try {
89343       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89344     } catch (std::out_of_range& e) {
89345       {
89346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89347       };
89348     } catch (std::exception& e) {
89349       {
89350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89351       };
89352     } catch (...) {
89353       {
89354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89355       };
89356     }
89357   }
89358 }
89359
89360
89361 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89362   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89363   Dali::Actor arg2 ;
89364   bool arg3 ;
89365   Dali::Actor *argp2 ;
89366
89367   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89368   argp2 = (Dali::Actor *)jarg2;
89369   if (!argp2) {
89370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89371     return ;
89372   }
89373   arg2 = *argp2;
89374   arg3 = jarg3 ? true : false;
89375   {
89376     try {
89377       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89378     } catch (std::out_of_range& e) {
89379       {
89380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89381       };
89382     } catch (std::exception& e) {
89383       {
89384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89385       };
89386     } catch (...) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89389       };
89390     }
89391   }
89392 }
89393
89394
89395 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_FocusGroupChangedSignal() {
89396   void * jresult ;
89397   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89398
89399   {
89400     try {
89401       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89402     } catch (std::out_of_range& e) {
89403       {
89404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89405       };
89406     } catch (std::exception& e) {
89407       {
89408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89409       };
89410     } catch (...) {
89411       {
89412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89413       };
89414     }
89415   }
89416   jresult = (void *)result;
89417   return jresult;
89418 }
89419
89420
89421 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_FocusGroupChangedSignal(void * jarg1) {
89422   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89423
89424   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89425   {
89426     try {
89427       delete arg1;
89428     } catch (std::out_of_range& e) {
89429       {
89430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89431       };
89432     } catch (std::exception& e) {
89433       {
89434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89435       };
89436     } catch (...) {
89437       {
89438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89439       };
89440     }
89441   }
89442 }
89443
89444
89445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Empty(void * jarg1) {
89446   unsigned int jresult ;
89447   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89448   bool result;
89449
89450   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89451   {
89452     try {
89453       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);
89454     } catch (std::out_of_range& e) {
89455       {
89456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89457       };
89458     } catch (std::exception& e) {
89459       {
89460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89461       };
89462     } catch (...) {
89463       {
89464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89465       };
89466     }
89467   }
89468   jresult = result;
89469   return jresult;
89470 }
89471
89472
89473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89474   unsigned long jresult ;
89475   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89476   std::size_t result;
89477
89478   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89479   {
89480     try {
89481       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);
89482     } catch (std::out_of_range& e) {
89483       {
89484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89485       };
89486     } catch (std::exception& e) {
89487       {
89488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89489       };
89490     } catch (...) {
89491       {
89492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89493       };
89494     }
89495   }
89496   jresult = (unsigned long)result;
89497   return jresult;
89498 }
89499
89500
89501 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89502   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89503   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89504
89505   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89506   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89507   {
89508     try {
89509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89510     } catch (std::out_of_range& e) {
89511       {
89512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (std::exception& e) {
89515       {
89516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89517       };
89518     } catch (...) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89521       };
89522     }
89523   }
89524 }
89525
89526
89527 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89528   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89529   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89530
89531   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89532   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89533   {
89534     try {
89535       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89536     } catch (std::out_of_range& e) {
89537       {
89538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89539       };
89540     } catch (std::exception& e) {
89541       {
89542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89543       };
89544     } catch (...) {
89545       {
89546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89547       };
89548     }
89549   }
89550 }
89551
89552
89553 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89554   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89555   Dali::Toolkit::StyleManager arg2 ;
89556   Dali::StyleChange::Type arg3 ;
89557   Dali::Toolkit::StyleManager *argp2 ;
89558
89559   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89560   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89561   if (!argp2) {
89562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89563     return ;
89564   }
89565   arg2 = *argp2;
89566   arg3 = (Dali::StyleChange::Type)jarg3;
89567   {
89568     try {
89569       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89570     } catch (std::out_of_range& e) {
89571       {
89572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89573       };
89574     } catch (std::exception& e) {
89575       {
89576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89577       };
89578     } catch (...) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89581       };
89582     }
89583   }
89584 }
89585
89586
89587 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_StyleChangedSignal() {
89588   void * jresult ;
89589   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89590
89591   {
89592     try {
89593       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89594     } catch (std::out_of_range& e) {
89595       {
89596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89597       };
89598     } catch (std::exception& e) {
89599       {
89600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (...) {
89603       {
89604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89605       };
89606     }
89607   }
89608   jresult = (void *)result;
89609   return jresult;
89610 }
89611
89612
89613 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_StyleChangedSignal(void * jarg1) {
89614   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89615
89616   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89617   {
89618     try {
89619       delete arg1;
89620     } catch (std::out_of_range& e) {
89621       {
89622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89623       };
89624     } catch (std::exception& e) {
89625       {
89626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89631       };
89632     }
89633   }
89634 }
89635
89636
89637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ButtonSignal_Empty(void * jarg1) {
89638   unsigned int jresult ;
89639   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89640   bool result;
89641
89642   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89643   {
89644     try {
89645       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89646     } catch (std::out_of_range& e) {
89647       {
89648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89649       };
89650     } catch (std::exception& e) {
89651       {
89652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89657       };
89658     }
89659   }
89660   jresult = result;
89661   return jresult;
89662 }
89663
89664
89665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ButtonSignal_GetConnectionCount(void * jarg1) {
89666   unsigned long jresult ;
89667   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89668   std::size_t result;
89669
89670   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89671   {
89672     try {
89673       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89674     } catch (std::out_of_range& e) {
89675       {
89676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89677       };
89678     } catch (std::exception& e) {
89679       {
89680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89681       };
89682     } catch (...) {
89683       {
89684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89685       };
89686     }
89687   }
89688   jresult = (unsigned long)result;
89689   return jresult;
89690 }
89691
89692
89693 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89694   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89695   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89696
89697   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89698   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89699   {
89700     try {
89701       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89702     } catch (std::out_of_range& e) {
89703       {
89704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89705       };
89706     } catch (std::exception& e) {
89707       {
89708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (...) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89713       };
89714     }
89715   }
89716 }
89717
89718
89719 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89720   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89721   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89722
89723   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89724   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89725   {
89726     try {
89727       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89728     } catch (std::out_of_range& e) {
89729       {
89730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89731       };
89732     } catch (std::exception& e) {
89733       {
89734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89735       };
89736     } catch (...) {
89737       {
89738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89739       };
89740     }
89741   }
89742 }
89743
89744
89745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89746   unsigned int jresult ;
89747   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89748   Dali::Toolkit::Button arg2 ;
89749   Dali::Toolkit::Button *argp2 ;
89750   bool result;
89751
89752   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89753   argp2 = (Dali::Toolkit::Button *)jarg2;
89754   if (!argp2) {
89755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89756     return 0;
89757   }
89758   arg2 = *argp2;
89759   {
89760     try {
89761       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89762     } catch (std::out_of_range& e) {
89763       {
89764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89765       };
89766     } catch (std::exception& e) {
89767       {
89768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89769       };
89770     } catch (...) {
89771       {
89772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89773       };
89774     }
89775   }
89776   jresult = result;
89777   return jresult;
89778 }
89779
89780
89781 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ButtonSignal() {
89782   void * jresult ;
89783   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89784
89785   {
89786     try {
89787       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89788     } catch (std::out_of_range& e) {
89789       {
89790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89791       };
89792     } catch (std::exception& e) {
89793       {
89794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89795       };
89796     } catch (...) {
89797       {
89798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89799       };
89800     }
89801   }
89802   jresult = (void *)result;
89803   return jresult;
89804 }
89805
89806
89807 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ButtonSignal(void * jarg1) {
89808   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89809
89810   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89811   {
89812     try {
89813       delete arg1;
89814     } catch (std::out_of_range& e) {
89815       {
89816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (std::exception& e) {
89819       {
89820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89821       };
89822     } catch (...) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89825       };
89826     }
89827   }
89828 }
89829
89830
89831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Empty(void * jarg1) {
89832   unsigned int jresult ;
89833   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89834   bool result;
89835
89836   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89837   {
89838     try {
89839       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (...) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89851       };
89852     }
89853   }
89854   jresult = result;
89855   return jresult;
89856 }
89857
89858
89859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89860   unsigned long jresult ;
89861   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89862   std::size_t result;
89863
89864   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89865   {
89866     try {
89867       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89868     } catch (std::out_of_range& e) {
89869       {
89870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (std::exception& e) {
89873       {
89874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89879       };
89880     }
89881   }
89882   jresult = (unsigned long)result;
89883   return jresult;
89884 }
89885
89886
89887 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89888   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89889   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89890
89891   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89892   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89893   {
89894     try {
89895       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89896     } catch (std::out_of_range& e) {
89897       {
89898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89899       };
89900     } catch (std::exception& e) {
89901       {
89902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89903       };
89904     } catch (...) {
89905       {
89906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89907       };
89908     }
89909   }
89910 }
89911
89912
89913 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89914   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89915   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89916
89917   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89918   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89919   {
89920     try {
89921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89922     } catch (std::out_of_range& e) {
89923       {
89924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89925       };
89926     } catch (std::exception& e) {
89927       {
89928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89929       };
89930     } catch (...) {
89931       {
89932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89933       };
89934     }
89935   }
89936 }
89937
89938
89939 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89940   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89941   Dali::Toolkit::GaussianBlurView arg2 ;
89942   Dali::Toolkit::GaussianBlurView *argp2 ;
89943
89944   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89945   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89946   if (!argp2) {
89947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89948     return ;
89949   }
89950   arg2 = *argp2;
89951   {
89952     try {
89953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89954     } catch (std::out_of_range& e) {
89955       {
89956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89957       };
89958     } catch (std::exception& e) {
89959       {
89960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89961       };
89962     } catch (...) {
89963       {
89964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89965       };
89966     }
89967   }
89968 }
89969
89970
89971 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_GaussianBlurViewSignal() {
89972   void * jresult ;
89973   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89974
89975   {
89976     try {
89977       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89978     } catch (std::out_of_range& e) {
89979       {
89980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (std::exception& e) {
89983       {
89984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89985       };
89986     } catch (...) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89989       };
89990     }
89991   }
89992   jresult = (void *)result;
89993   return jresult;
89994 }
89995
89996
89997 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_GaussianBlurViewSignal(void * jarg1) {
89998   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89999
90000   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90001   {
90002     try {
90003       delete arg1;
90004     } catch (std::out_of_range& e) {
90005       {
90006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (std::exception& e) {
90009       {
90010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018 }
90019
90020
90021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PageTurnSignal_Empty(void * jarg1) {
90022   unsigned int jresult ;
90023   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90024   bool result;
90025
90026   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90027   {
90028     try {
90029       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);
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90041       };
90042     }
90043   }
90044   jresult = result;
90045   return jresult;
90046 }
90047
90048
90049 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PageTurnSignal_GetConnectionCount(void * jarg1) {
90050   unsigned long jresult ;
90051   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90052   std::size_t result;
90053
90054   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90055   {
90056     try {
90057       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);
90058     } catch (std::out_of_range& e) {
90059       {
90060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90061       };
90062     } catch (std::exception& e) {
90063       {
90064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90065       };
90066     } catch (...) {
90067       {
90068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90069       };
90070     }
90071   }
90072   jresult = (unsigned long)result;
90073   return jresult;
90074 }
90075
90076
90077 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90078   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90079   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90080
90081   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90082   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90083   {
90084     try {
90085       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90086     } catch (std::out_of_range& e) {
90087       {
90088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90089       };
90090     } catch (std::exception& e) {
90091       {
90092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90097       };
90098     }
90099   }
90100 }
90101
90102
90103 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90104   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90105   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90106
90107   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90108   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90109   {
90110     try {
90111       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90112     } catch (std::out_of_range& e) {
90113       {
90114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90115       };
90116     } catch (std::exception& e) {
90117       {
90118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90119       };
90120     } catch (...) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90123       };
90124     }
90125   }
90126 }
90127
90128
90129 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90130   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90131   Dali::Toolkit::PageTurnView arg2 ;
90132   unsigned int arg3 ;
90133   bool arg4 ;
90134   Dali::Toolkit::PageTurnView *argp2 ;
90135
90136   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90137   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90138   if (!argp2) {
90139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90140     return ;
90141   }
90142   arg2 = *argp2;
90143   arg3 = (unsigned int)jarg3;
90144   arg4 = jarg4 ? true : false;
90145   {
90146     try {
90147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90148     } catch (std::out_of_range& e) {
90149       {
90150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90151       };
90152     } catch (std::exception& e) {
90153       {
90154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90155       };
90156     } catch (...) {
90157       {
90158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90159       };
90160     }
90161   }
90162 }
90163
90164
90165 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PageTurnSignal() {
90166   void * jresult ;
90167   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90168
90169   {
90170     try {
90171       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90172     } catch (std::out_of_range& e) {
90173       {
90174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90175       };
90176     } catch (std::exception& e) {
90177       {
90178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (...) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90183       };
90184     }
90185   }
90186   jresult = (void *)result;
90187   return jresult;
90188 }
90189
90190
90191 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PageTurnSignal(void * jarg1) {
90192   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90193
90194   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90195   {
90196     try {
90197       delete arg1;
90198     } catch (std::out_of_range& e) {
90199       {
90200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90201       };
90202     } catch (std::exception& e) {
90203       {
90204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90205       };
90206     } catch (...) {
90207       {
90208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90209       };
90210     }
90211   }
90212 }
90213
90214
90215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_PagePanSignal_Empty(void * jarg1) {
90216   unsigned int jresult ;
90217   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90218   bool result;
90219
90220   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90221   {
90222     try {
90223       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90224     } catch (std::out_of_range& e) {
90225       {
90226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90227       };
90228     } catch (std::exception& e) {
90229       {
90230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90231       };
90232     } catch (...) {
90233       {
90234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90235       };
90236     }
90237   }
90238   jresult = result;
90239   return jresult;
90240 }
90241
90242
90243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_PagePanSignal_GetConnectionCount(void * jarg1) {
90244   unsigned long jresult ;
90245   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90246   std::size_t result;
90247
90248   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90249   {
90250     try {
90251       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90252     } catch (std::out_of_range& e) {
90253       {
90254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90255       };
90256     } catch (std::exception& e) {
90257       {
90258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90259       };
90260     } catch (...) {
90261       {
90262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90263       };
90264     }
90265   }
90266   jresult = (unsigned long)result;
90267   return jresult;
90268 }
90269
90270
90271 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90272   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90273   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90274
90275   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90276   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90277   {
90278     try {
90279       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90280     } catch (std::out_of_range& e) {
90281       {
90282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90283       };
90284     } catch (std::exception& e) {
90285       {
90286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90287       };
90288     } catch (...) {
90289       {
90290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90291       };
90292     }
90293   }
90294 }
90295
90296
90297 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90298   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90299   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90300
90301   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90302   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90303   {
90304     try {
90305       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90306     } catch (std::out_of_range& e) {
90307       {
90308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90309       };
90310     } catch (std::exception& e) {
90311       {
90312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90313       };
90314     } catch (...) {
90315       {
90316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90317       };
90318     }
90319   }
90320 }
90321
90322
90323 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90324   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90325   Dali::Toolkit::PageTurnView arg2 ;
90326   Dali::Toolkit::PageTurnView *argp2 ;
90327
90328   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90329   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90330   if (!argp2) {
90331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90332     return ;
90333   }
90334   arg2 = *argp2;
90335   {
90336     try {
90337       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90338     } catch (std::out_of_range& e) {
90339       {
90340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90341       };
90342     } catch (std::exception& e) {
90343       {
90344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (...) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90349       };
90350     }
90351   }
90352 }
90353
90354
90355 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_PagePanSignal() {
90356   void * jresult ;
90357   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90358
90359   {
90360     try {
90361       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90362     } catch (std::out_of_range& e) {
90363       {
90364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (std::exception& e) {
90367       {
90368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90369       };
90370     } catch (...) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90373       };
90374     }
90375   }
90376   jresult = (void *)result;
90377   return jresult;
90378 }
90379
90380
90381 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_PagePanSignal(void * jarg1) {
90382   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90383
90384   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90385   {
90386     try {
90387       delete arg1;
90388     } catch (std::out_of_range& e) {
90389       {
90390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90391       };
90392     } catch (std::exception& e) {
90393       {
90394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90395       };
90396     } catch (...) {
90397       {
90398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90399       };
90400     }
90401   }
90402 }
90403
90404
90405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90406   unsigned int jresult ;
90407   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90408   bool result;
90409
90410   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90411   {
90412     try {
90413       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);
90414     } catch (std::out_of_range& e) {
90415       {
90416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90417       };
90418     } catch (std::exception& e) {
90419       {
90420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90421       };
90422     } catch (...) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90425       };
90426     }
90427   }
90428   jresult = result;
90429   return jresult;
90430 }
90431
90432
90433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90434   unsigned long jresult ;
90435   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90436   std::size_t result;
90437
90438   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90439   {
90440     try {
90441       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);
90442     } catch (std::out_of_range& e) {
90443       {
90444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90445       };
90446     } catch (std::exception& e) {
90447       {
90448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90449       };
90450     } catch (...) {
90451       {
90452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90453       };
90454     }
90455   }
90456   jresult = (unsigned long)result;
90457   return jresult;
90458 }
90459
90460
90461 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90462   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90463   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90464
90465   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90466   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90467   {
90468     try {
90469       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90470     } catch (std::out_of_range& e) {
90471       {
90472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90473       };
90474     } catch (std::exception& e) {
90475       {
90476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90477       };
90478     } catch (...) {
90479       {
90480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90481       };
90482     }
90483   }
90484 }
90485
90486
90487 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90488   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90489   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90490
90491   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90492   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90493   {
90494     try {
90495       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90496     } catch (std::out_of_range& e) {
90497       {
90498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90499       };
90500     } catch (std::exception& e) {
90501       {
90502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90503       };
90504     } catch (...) {
90505       {
90506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90507       };
90508     }
90509   }
90510 }
90511
90512
90513 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90514   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90515   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90516
90517   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90518   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90519   if (!arg2) {
90520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90521     return ;
90522   }
90523   {
90524     try {
90525       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90526     } catch (std::out_of_range& e) {
90527       {
90528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90529       };
90530     } catch (std::exception& e) {
90531       {
90532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90533       };
90534     } catch (...) {
90535       {
90536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90537       };
90538     }
90539   }
90540 }
90541
90542
90543 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollViewSnapStartedSignal() {
90544   void * jresult ;
90545   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90546
90547   {
90548     try {
90549       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90557       };
90558     } catch (...) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90561       };
90562     }
90563   }
90564   jresult = (void *)result;
90565   return jresult;
90566 }
90567
90568
90569 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90570   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90571
90572   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90573   {
90574     try {
90575       delete arg1;
90576     } catch (std::out_of_range& e) {
90577       {
90578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90579       };
90580     } catch (std::exception& e) {
90581       {
90582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90583       };
90584     } catch (...) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90587       };
90588     }
90589   }
90590 }
90591
90592
90593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ScrollableSignal_Empty(void * jarg1) {
90594   unsigned int jresult ;
90595   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90596   bool result;
90597
90598   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90599   {
90600     try {
90601       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90602     } catch (std::out_of_range& e) {
90603       {
90604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90605       };
90606     } catch (std::exception& e) {
90607       {
90608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90609       };
90610     } catch (...) {
90611       {
90612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90613       };
90614     }
90615   }
90616   jresult = result;
90617   return jresult;
90618 }
90619
90620
90621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ScrollableSignal_GetConnectionCount(void * jarg1) {
90622   unsigned long jresult ;
90623   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90624   std::size_t result;
90625
90626   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90627   {
90628     try {
90629       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90630     } catch (std::out_of_range& e) {
90631       {
90632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90633       };
90634     } catch (std::exception& e) {
90635       {
90636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90637       };
90638     } catch (...) {
90639       {
90640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90641       };
90642     }
90643   }
90644   jresult = (unsigned long)result;
90645   return jresult;
90646 }
90647
90648
90649 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90650   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90651   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90652
90653   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90654   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90655   {
90656     try {
90657       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90658     } catch (std::out_of_range& e) {
90659       {
90660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90661       };
90662     } catch (std::exception& e) {
90663       {
90664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90665       };
90666     } catch (...) {
90667       {
90668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90669       };
90670     }
90671   }
90672 }
90673
90674
90675 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90676   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90677   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90678
90679   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90680   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90681   {
90682     try {
90683       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90684     } catch (std::out_of_range& e) {
90685       {
90686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90687       };
90688     } catch (std::exception& e) {
90689       {
90690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90691       };
90692     } catch (...) {
90693       {
90694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90695       };
90696     }
90697   }
90698 }
90699
90700
90701 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90702   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90703   Dali::Vector2 *arg2 = 0 ;
90704
90705   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90706   arg2 = (Dali::Vector2 *)jarg2;
90707   if (!arg2) {
90708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90709     return ;
90710   }
90711   {
90712     try {
90713       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90714     } catch (std::out_of_range& e) {
90715       {
90716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90717       };
90718     } catch (std::exception& e) {
90719       {
90720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90721       };
90722     } catch (...) {
90723       {
90724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90725       };
90726     }
90727   }
90728 }
90729
90730
90731 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ScrollableSignal() {
90732   void * jresult ;
90733   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90734
90735   {
90736     try {
90737       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (...) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90749       };
90750     }
90751   }
90752   jresult = (void *)result;
90753   return jresult;
90754 }
90755
90756
90757 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ScrollableSignal(void * jarg1) {
90758   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90759
90760   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90761   {
90762     try {
90763       delete arg1;
90764     } catch (std::out_of_range& e) {
90765       {
90766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90767       };
90768     } catch (std::exception& e) {
90769       {
90770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90771       };
90772     } catch (...) {
90773       {
90774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90775       };
90776     }
90777   }
90778 }
90779
90780
90781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TextEditorSignal_Empty(void * jarg1) {
90782   unsigned int jresult ;
90783   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90784   bool result;
90785
90786   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90787   {
90788     try {
90789       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90801       };
90802     }
90803   }
90804   jresult = result;
90805   return jresult;
90806 }
90807
90808
90809 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextEditorSignal_GetConnectionCount(void * jarg1) {
90810   unsigned long jresult ;
90811   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90812   std::size_t result;
90813
90814   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90815   {
90816     try {
90817       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90818     } catch (std::out_of_range& e) {
90819       {
90820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90821       };
90822     } catch (std::exception& e) {
90823       {
90824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90825       };
90826     } catch (...) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90829       };
90830     }
90831   }
90832   jresult = (unsigned long)result;
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90838   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90839   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90840
90841   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90842   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90843   {
90844     try {
90845       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90846     } catch (std::out_of_range& e) {
90847       {
90848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90849       };
90850     } catch (std::exception& e) {
90851       {
90852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90853       };
90854     } catch (...) {
90855       {
90856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90857       };
90858     }
90859   }
90860 }
90861
90862
90863 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90864   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90865   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90866
90867   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90868   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90869   {
90870     try {
90871       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90872     } catch (std::out_of_range& e) {
90873       {
90874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90875       };
90876     } catch (std::exception& e) {
90877       {
90878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90879       };
90880     } catch (...) {
90881       {
90882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90883       };
90884     }
90885   }
90886 }
90887
90888
90889 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90890   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90891   Dali::Toolkit::TextEditor arg2 ;
90892   Dali::Toolkit::TextEditor *argp2 ;
90893
90894   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90895   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90896   if (!argp2) {
90897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90898     return ;
90899   }
90900   arg2 = *argp2;
90901   {
90902     try {
90903       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90904     } catch (std::out_of_range& e) {
90905       {
90906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90907       };
90908     } catch (std::exception& e) {
90909       {
90910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90911       };
90912     } catch (...) {
90913       {
90914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90915       };
90916     }
90917   }
90918 }
90919
90920
90921 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextEditorSignal() {
90922   void * jresult ;
90923   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90924
90925   {
90926     try {
90927       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90928     } catch (std::out_of_range& e) {
90929       {
90930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (std::exception& e) {
90933       {
90934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (...) {
90937       {
90938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90939       };
90940     }
90941   }
90942   jresult = (void *)result;
90943   return jresult;
90944 }
90945
90946
90947 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextEditorSignal(void * jarg1) {
90948   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90949
90950   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90951   {
90952     try {
90953       delete arg1;
90954     } catch (std::out_of_range& e) {
90955       {
90956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90957       };
90958     } catch (std::exception& e) {
90959       {
90960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (...) {
90963       {
90964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90965       };
90966     }
90967   }
90968 }
90969
90970
90971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_TextFieldSignal_Empty(void * jarg1) {
90972   unsigned int jresult ;
90973   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90974   bool result;
90975
90976   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90977   {
90978     try {
90979       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90980     } catch (std::out_of_range& e) {
90981       {
90982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (std::exception& e) {
90985       {
90986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90987       };
90988     } catch (...) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90991       };
90992     }
90993   }
90994   jresult = result;
90995   return jresult;
90996 }
90997
90998
90999 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_TextFieldSignal_GetConnectionCount(void * jarg1) {
91000   unsigned long jresult ;
91001   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91002   std::size_t result;
91003
91004   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91005   {
91006     try {
91007       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91008     } catch (std::out_of_range& e) {
91009       {
91010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91011       };
91012     } catch (std::exception& e) {
91013       {
91014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91015       };
91016     } catch (...) {
91017       {
91018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91019       };
91020     }
91021   }
91022   jresult = (unsigned long)result;
91023   return jresult;
91024 }
91025
91026
91027 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91028   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91029   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91030
91031   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91032   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91033   {
91034     try {
91035       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91036     } catch (std::out_of_range& e) {
91037       {
91038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91039       };
91040     } catch (std::exception& e) {
91041       {
91042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91043       };
91044     } catch (...) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91047       };
91048     }
91049   }
91050 }
91051
91052
91053 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91054   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91055   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91056
91057   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91058   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91059   {
91060     try {
91061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91062     } catch (std::out_of_range& e) {
91063       {
91064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91065       };
91066     } catch (std::exception& e) {
91067       {
91068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (...) {
91071       {
91072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91073       };
91074     }
91075   }
91076 }
91077
91078
91079 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91080   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91081   Dali::Toolkit::TextField arg2 ;
91082   Dali::Toolkit::TextField *argp2 ;
91083
91084   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91085   argp2 = (Dali::Toolkit::TextField *)jarg2;
91086   if (!argp2) {
91087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91088     return ;
91089   }
91090   arg2 = *argp2;
91091   {
91092     try {
91093       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91094     } catch (std::out_of_range& e) {
91095       {
91096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91097       };
91098     } catch (std::exception& e) {
91099       {
91100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91101       };
91102     } catch (...) {
91103       {
91104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91105       };
91106     }
91107   }
91108 }
91109
91110
91111 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_TextFieldSignal() {
91112   void * jresult ;
91113   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91114
91115   {
91116     try {
91117       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91118     } catch (std::out_of_range& e) {
91119       {
91120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91121       };
91122     } catch (std::exception& e) {
91123       {
91124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91125       };
91126     } catch (...) {
91127       {
91128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91129       };
91130     }
91131   }
91132   jresult = (void *)result;
91133   return jresult;
91134 }
91135
91136
91137 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_TextFieldSignal(void * jarg1) {
91138   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91139
91140   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91141   {
91142     try {
91143       delete arg1;
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91151       };
91152     } catch (...) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91155       };
91156     }
91157   }
91158 }
91159
91160
91161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Empty(void * jarg1) {
91162   unsigned int jresult ;
91163   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91164   bool result;
91165
91166   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91167   {
91168     try {
91169       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);
91170     } catch (std::out_of_range& e) {
91171       {
91172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91173       };
91174     } catch (std::exception& e) {
91175       {
91176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91177       };
91178     } catch (...) {
91179       {
91180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91181       };
91182     }
91183   }
91184   jresult = result;
91185   return jresult;
91186 }
91187
91188
91189 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_GetConnectionCount(void * jarg1) {
91190   unsigned long jresult ;
91191   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91192   std::size_t result;
91193
91194   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91195   {
91196     try {
91197       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);
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91209       };
91210     }
91211   }
91212   jresult = (unsigned long)result;
91213   return jresult;
91214 }
91215
91216
91217 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Connect(void * jarg1, void * jarg2) {
91218   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91219   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91220
91221   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91222   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91223   {
91224     try {
91225       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91226     } catch (std::out_of_range& e) {
91227       {
91228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91229       };
91230     } catch (std::exception& e) {
91231       {
91232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91233       };
91234     } catch (...) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91237       };
91238     }
91239   }
91240 }
91241
91242
91243 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
91244   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91245   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91246
91247   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91248   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91249   {
91250     try {
91251       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91252     } catch (std::out_of_range& e) {
91253       {
91254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (std::exception& e) {
91257       {
91258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91263       };
91264     }
91265   }
91266 }
91267
91268
91269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_ControlKeyEventSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91270   unsigned int jresult ;
91271   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91272   Dali::Toolkit::Control arg2 ;
91273   Dali::KeyEvent *arg3 = 0 ;
91274   Dali::Toolkit::Control *argp2 ;
91275   bool result;
91276
91277   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91278   argp2 = (Dali::Toolkit::Control *)jarg2;
91279   if (!argp2) {
91280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91281     return 0;
91282   }
91283   arg2 = *argp2;
91284   arg3 = (Dali::KeyEvent *)jarg3;
91285   if (!arg3) {
91286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91287     return 0;
91288   }
91289   {
91290     try {
91291       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);
91292     } catch (std::out_of_range& e) {
91293       {
91294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91295       };
91296     } catch (std::exception& e) {
91297       {
91298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91299       };
91300     } catch (...) {
91301       {
91302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91303       };
91304     }
91305   }
91306   jresult = result;
91307   return jresult;
91308 }
91309
91310
91311 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_ControlKeyEventSignal() {
91312   void * jresult ;
91313   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91314
91315   {
91316     try {
91317       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91318     } catch (std::out_of_range& e) {
91319       {
91320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91321       };
91322     } catch (std::exception& e) {
91323       {
91324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91325       };
91326     } catch (...) {
91327       {
91328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91329       };
91330     }
91331   }
91332   jresult = (void *)result;
91333   return jresult;
91334 }
91335
91336
91337 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_ControlKeyEventSignal(void * jarg1) {
91338   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91339
91340   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91341   {
91342     try {
91343       delete arg1;
91344     } catch (std::out_of_range& e) {
91345       {
91346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91347       };
91348     } catch (std::exception& e) {
91349       {
91350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91351       };
91352     } catch (...) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91355       };
91356     }
91357   }
91358 }
91359
91360
91361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Empty(void * jarg1) {
91362   unsigned int jresult ;
91363   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91364   bool result;
91365
91366   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91367   {
91368     try {
91369       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91370     } catch (std::out_of_range& e) {
91371       {
91372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91373       };
91374     } catch (std::exception& e) {
91375       {
91376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91377       };
91378     } catch (...) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91381       };
91382     }
91383   }
91384   jresult = result;
91385   return jresult;
91386 }
91387
91388
91389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91390   unsigned long jresult ;
91391   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91392   std::size_t result;
91393
91394   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91395   {
91396     try {
91397       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91398     } catch (std::out_of_range& e) {
91399       {
91400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91401       };
91402     } catch (std::exception& e) {
91403       {
91404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91409       };
91410     }
91411   }
91412   jresult = (unsigned long)result;
91413   return jresult;
91414 }
91415
91416
91417 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91418   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91419   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91420
91421   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91422   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91423   {
91424     try {
91425       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91426     } catch (std::out_of_range& e) {
91427       {
91428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91429       };
91430     } catch (std::exception& e) {
91431       {
91432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91433       };
91434     } catch (...) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91437       };
91438     }
91439   }
91440 }
91441
91442
91443 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91444   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91445   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91446
91447   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91448   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91449   {
91450     try {
91451       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91459       };
91460     } catch (...) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91463       };
91464     }
91465   }
91466 }
91467
91468
91469 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91470   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91471   Dali::Toolkit::Control arg2 ;
91472   Dali::Toolkit::Control *argp2 ;
91473
91474   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91475   argp2 = (Dali::Toolkit::Control *)jarg2;
91476   if (!argp2) {
91477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91478     return ;
91479   }
91480   arg2 = *argp2;
91481   {
91482     try {
91483       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91484     } catch (std::out_of_range& e) {
91485       {
91486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91487       };
91488     } catch (std::exception& e) {
91489       {
91490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91491       };
91492     } catch (...) {
91493       {
91494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91495       };
91496     }
91497   }
91498 }
91499
91500
91501 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_KeyInputFocusSignal() {
91502   void * jresult ;
91503   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91504
91505   {
91506     try {
91507       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91508     } catch (std::out_of_range& e) {
91509       {
91510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (std::exception& e) {
91513       {
91514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91515       };
91516     } catch (...) {
91517       {
91518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91519       };
91520     }
91521   }
91522   jresult = (void *)result;
91523   return jresult;
91524 }
91525
91526
91527 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_KeyInputFocusSignal(void * jarg1) {
91528   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91529
91530   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91531   {
91532     try {
91533       delete arg1;
91534     } catch (std::out_of_range& e) {
91535       {
91536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91537       };
91538     } catch (std::exception& e) {
91539       {
91540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91541       };
91542     } catch (...) {
91543       {
91544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91545       };
91546     }
91547   }
91548 }
91549
91550
91551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_VideoViewSignal_Empty(void * jarg1) {
91552   unsigned int jresult ;
91553   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91554   bool result;
91555
91556   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91557   {
91558     try {
91559       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91560     } catch (std::out_of_range& e) {
91561       {
91562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91563       };
91564     } catch (std::exception& e) {
91565       {
91566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91571       };
91572     }
91573   }
91574   jresult = result;
91575   return jresult;
91576 }
91577
91578
91579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_VideoViewSignal_GetConnectionCount(void * jarg1) {
91580   unsigned long jresult ;
91581   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91582   std::size_t result;
91583
91584   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91585   {
91586     try {
91587       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91588     } catch (std::out_of_range& e) {
91589       {
91590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91591       };
91592     } catch (std::exception& e) {
91593       {
91594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (...) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91599       };
91600     }
91601   }
91602   jresult = (unsigned long)result;
91603   return jresult;
91604 }
91605
91606
91607 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91608   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91609   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91610
91611   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91612   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91613   {
91614     try {
91615       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91623       };
91624     } catch (...) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91627       };
91628     }
91629   }
91630 }
91631
91632
91633 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91634   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91635   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91636
91637   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91638   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91639   {
91640     try {
91641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91649       };
91650     } catch (...) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91653       };
91654     }
91655   }
91656 }
91657
91658
91659 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91660   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91661   Dali::Toolkit::VideoView *arg2 = 0 ;
91662
91663   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91664   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91665   if (!arg2) {
91666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91667     return ;
91668   }
91669   {
91670     try {
91671       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91672     } catch (std::out_of_range& e) {
91673       {
91674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91675       };
91676     } catch (std::exception& e) {
91677       {
91678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91679       };
91680     } catch (...) {
91681       {
91682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91683       };
91684     }
91685   }
91686 }
91687
91688
91689 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_VideoViewSignal() {
91690   void * jresult ;
91691   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91692
91693   {
91694     try {
91695       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91696     } catch (std::out_of_range& e) {
91697       {
91698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91699       };
91700     } catch (std::exception& e) {
91701       {
91702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91707       };
91708     }
91709   }
91710   jresult = (void *)result;
91711   return jresult;
91712 }
91713
91714
91715 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_VideoViewSignal(void * jarg1) {
91716   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91717
91718   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91719   {
91720     try {
91721       delete arg1;
91722     } catch (std::out_of_range& e) {
91723       {
91724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91725       };
91726     } catch (std::exception& e) {
91727       {
91728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91729       };
91730     } catch (...) {
91731       {
91732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91733       };
91734     }
91735   }
91736 }
91737
91738
91739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Empty(void * jarg1) {
91740   unsigned int jresult ;
91741   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91742   bool result;
91743
91744   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91745   {
91746     try {
91747       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91748     } catch (std::out_of_range& e) {
91749       {
91750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91751       };
91752     } catch (std::exception& e) {
91753       {
91754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91755       };
91756     } catch (...) {
91757       {
91758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91759       };
91760     }
91761   }
91762   jresult = result;
91763   return jresult;
91764 }
91765
91766
91767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91768   unsigned long jresult ;
91769   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91770   std::size_t result;
91771
91772   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91773   {
91774     try {
91775       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91776     } catch (std::out_of_range& e) {
91777       {
91778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91779       };
91780     } catch (std::exception& e) {
91781       {
91782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91783       };
91784     } catch (...) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91787       };
91788     }
91789   }
91790   jresult = (unsigned long)result;
91791   return jresult;
91792 }
91793
91794
91795 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91796   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91797   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91798
91799   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91800   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91801   {
91802     try {
91803       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91804     } catch (std::out_of_range& e) {
91805       {
91806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91807       };
91808     } catch (std::exception& e) {
91809       {
91810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91811       };
91812     } catch (...) {
91813       {
91814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91815       };
91816     }
91817   }
91818 }
91819
91820
91821 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91822   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91823   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91824
91825   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91826   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91827   {
91828     try {
91829       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91830     } catch (std::out_of_range& e) {
91831       {
91832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91833       };
91834     } catch (std::exception& e) {
91835       {
91836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91837       };
91838     } catch (...) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91841       };
91842     }
91843   }
91844 }
91845
91846
91847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91848   unsigned int jresult ;
91849   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91850   Dali::Toolkit::Slider arg2 ;
91851   float arg3 ;
91852   Dali::Toolkit::Slider *argp2 ;
91853   bool result;
91854
91855   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91856   argp2 = (Dali::Toolkit::Slider *)jarg2;
91857   if (!argp2) {
91858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91859     return 0;
91860   }
91861   arg2 = *argp2;
91862   arg3 = (float)jarg3;
91863   {
91864     try {
91865       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (...) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91877       };
91878     }
91879   }
91880   jresult = result;
91881   return jresult;
91882 }
91883
91884
91885 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SliderValueChangedSignal() {
91886   void * jresult ;
91887   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91888
91889   {
91890     try {
91891       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91892     } catch (std::out_of_range& e) {
91893       {
91894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91895       };
91896     } catch (std::exception& e) {
91897       {
91898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91899       };
91900     } catch (...) {
91901       {
91902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91903       };
91904     }
91905   }
91906   jresult = (void *)result;
91907   return jresult;
91908 }
91909
91910
91911 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SliderValueChangedSignal(void * jarg1) {
91912   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91913
91914   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91915   {
91916     try {
91917       delete arg1;
91918     } catch (std::out_of_range& e) {
91919       {
91920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91921       };
91922     } catch (std::exception& e) {
91923       {
91924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91925       };
91926     } catch (...) {
91927       {
91928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91929       };
91930     }
91931   }
91932 }
91933
91934
91935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Empty(void * jarg1) {
91936   unsigned int jresult ;
91937   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91938   bool result;
91939
91940   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91941   {
91942     try {
91943       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91944     } catch (std::out_of_range& e) {
91945       {
91946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91947       };
91948     } catch (std::exception& e) {
91949       {
91950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91951       };
91952     } catch (...) {
91953       {
91954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91955       };
91956     }
91957   }
91958   jresult = result;
91959   return jresult;
91960 }
91961
91962
91963 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91964   unsigned long jresult ;
91965   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91966   std::size_t result;
91967
91968   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91969   {
91970     try {
91971       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91972     } catch (std::out_of_range& e) {
91973       {
91974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91975       };
91976     } catch (std::exception& e) {
91977       {
91978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91979       };
91980     } catch (...) {
91981       {
91982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91983       };
91984     }
91985   }
91986   jresult = (unsigned long)result;
91987   return jresult;
91988 }
91989
91990
91991 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91992   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91993   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91994
91995   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91996   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91997   {
91998     try {
91999       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92000     } catch (std::out_of_range& e) {
92001       {
92002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92003       };
92004     } catch (std::exception& e) {
92005       {
92006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92007       };
92008     } catch (...) {
92009       {
92010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92011       };
92012     }
92013   }
92014 }
92015
92016
92017 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92018   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92019   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92020
92021   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92022   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92023   {
92024     try {
92025       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92033       };
92034     } catch (...) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92037       };
92038     }
92039   }
92040 }
92041
92042
92043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92044   unsigned int jresult ;
92045   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92046   Dali::Toolkit::Slider arg2 ;
92047   int arg3 ;
92048   Dali::Toolkit::Slider *argp2 ;
92049   bool result;
92050
92051   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92052   argp2 = (Dali::Toolkit::Slider *)jarg2;
92053   if (!argp2) {
92054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92055     return 0;
92056   }
92057   arg2 = *argp2;
92058   arg3 = (int)jarg3;
92059   {
92060     try {
92061       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92062     } catch (std::out_of_range& e) {
92063       {
92064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92065       };
92066     } catch (std::exception& e) {
92067       {
92068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92069       };
92070     } catch (...) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92073       };
92074     }
92075   }
92076   jresult = result;
92077   return jresult;
92078 }
92079
92080
92081 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_SliderMarkReachedSignal() {
92082   void * jresult ;
92083   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92084
92085   {
92086     try {
92087       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92088     } catch (std::out_of_range& e) {
92089       {
92090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (std::exception& e) {
92093       {
92094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92095       };
92096     } catch (...) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92099       };
92100     }
92101   }
92102   jresult = (void *)result;
92103   return jresult;
92104 }
92105
92106
92107 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_SliderMarkReachedSignal(void * jarg1) {
92108   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92109
92110   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92111   {
92112     try {
92113       delete arg1;
92114     } catch (std::out_of_range& e) {
92115       {
92116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92117       };
92118     } catch (std::exception& e) {
92119       {
92120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92121       };
92122     } catch (...) {
92123       {
92124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92125       };
92126     }
92127   }
92128 }
92129
92130
92131 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_0() {
92132   void * jresult ;
92133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92134
92135   {
92136     try {
92137       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92138     } catch (std::out_of_range& e) {
92139       {
92140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92141       };
92142     } catch (std::exception& e) {
92143       {
92144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92145       };
92146     } catch (...) {
92147       {
92148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92149       };
92150     }
92151   }
92152   jresult = (void *)result;
92153   return jresult;
92154 }
92155
92156
92157 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_1(void * jarg1) {
92158   void * jresult ;
92159   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92161
92162   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92163   {
92164     try {
92165       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92166     } catch (std::out_of_range& e) {
92167       {
92168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92169       };
92170     } catch (std::exception& e) {
92171       {
92172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92173       };
92174     } catch (...) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92177       };
92178     }
92179   }
92180   jresult = (void *)result;
92181   return jresult;
92182 }
92183
92184
92185 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_new_RulerPtr__SWIG_2(void * jarg1) {
92186   void * jresult ;
92187   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92188   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92189
92190   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92191   if (!arg1) {
92192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92193     return 0;
92194   }
92195   {
92196     try {
92197       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92198     } catch (std::out_of_range& e) {
92199       {
92200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92201       };
92202     } catch (std::exception& e) {
92203       {
92204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92205       };
92206     } catch (...) {
92207       {
92208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92209       };
92210     }
92211   }
92212   jresult = (void *)result;
92213   return jresult;
92214 }
92215
92216
92217 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_delete_RulerPtr(void * jarg1) {
92218   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92219
92220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92221   {
92222     try {
92223       delete arg1;
92224     } catch (std::out_of_range& e) {
92225       {
92226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92227       };
92228     } catch (std::exception& e) {
92229       {
92230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92231       };
92232     } catch (...) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92235       };
92236     }
92237   }
92238 }
92239
92240
92241 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Get(void * jarg1) {
92242   void * jresult ;
92243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92244   Dali::Toolkit::Ruler *result = 0 ;
92245
92246   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92247   {
92248     try {
92249       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92250     } catch (std::out_of_range& e) {
92251       {
92252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92253       };
92254     } catch (std::exception& e) {
92255       {
92256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (...) {
92259       {
92260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92261       };
92262     }
92263   }
92264   jresult = (void *)result;
92265   return jresult;
92266 }
92267
92268
92269 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr___deref__(void * jarg1) {
92270   void * jresult ;
92271   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92272   Dali::Toolkit::Ruler *result = 0 ;
92273
92274   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92275   {
92276     try {
92277       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92278     } catch (std::out_of_range& e) {
92279       {
92280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92281       };
92282     } catch (std::exception& e) {
92283       {
92284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92285       };
92286     } catch (...) {
92287       {
92288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92289       };
92290     }
92291   }
92292   jresult = (void *)result;
92293   return jresult;
92294 }
92295
92296
92297 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr___ref__(void * jarg1) {
92298   void * jresult ;
92299   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92300   Dali::Toolkit::Ruler *result = 0 ;
92301
92302   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92303   {
92304     try {
92305       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92306     } catch (std::out_of_range& e) {
92307       {
92308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92309       };
92310     } catch (std::exception& e) {
92311       {
92312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92313       };
92314     } catch (...) {
92315       {
92316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92317       };
92318     }
92319   }
92320   jresult = (void *)result;
92321   return jresult;
92322 }
92323
92324
92325 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92326   void * jresult ;
92327   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92328   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92330
92331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92332   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92333   if (!arg2) {
92334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92335     return 0;
92336   }
92337   {
92338     try {
92339       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92340     } catch (std::out_of_range& e) {
92341       {
92342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (std::exception& e) {
92345       {
92346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92347       };
92348     } catch (...) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92351       };
92352     }
92353   }
92354   jresult = (void *)result;
92355   return jresult;
92356 }
92357
92358
92359 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92360   void * jresult ;
92361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92362   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92364
92365   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92366   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92367   {
92368     try {
92369       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92370     } catch (std::out_of_range& e) {
92371       {
92372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92373       };
92374     } catch (std::exception& e) {
92375       {
92376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92377       };
92378     } catch (...) {
92379       {
92380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92381       };
92382     }
92383   }
92384   jresult = (void *)result;
92385   return jresult;
92386 }
92387
92388
92389 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reset__SWIG_0(void * jarg1) {
92390   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92391
92392   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92393   {
92394     try {
92395       (arg1)->Reset();
92396     } catch (std::out_of_range& e) {
92397       {
92398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92399       };
92400     } catch (std::exception& e) {
92401       {
92402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92403       };
92404     } catch (...) {
92405       {
92406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92407       };
92408     }
92409   }
92410 }
92411
92412
92413 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92414   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92415   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92416
92417   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92418   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92419   {
92420     try {
92421       (arg1)->Reset(arg2);
92422     } catch (std::out_of_range& e) {
92423       {
92424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92425       };
92426     } catch (std::exception& e) {
92427       {
92428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92429       };
92430     } catch (...) {
92431       {
92432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92433       };
92434     }
92435   }
92436 }
92437
92438
92439 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_Detach(void * jarg1) {
92440   void * jresult ;
92441   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92442   Dali::Toolkit::Ruler *result = 0 ;
92443
92444   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92445   {
92446     try {
92447       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92448     } catch (std::out_of_range& e) {
92449       {
92450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92451       };
92452     } catch (std::exception& e) {
92453       {
92454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92455       };
92456     } catch (...) {
92457       {
92458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92459       };
92460     }
92461   }
92462   jresult = (void *)result;
92463   return jresult;
92464 }
92465
92466
92467 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92468   float jresult ;
92469   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92470   float arg2 ;
92471   float arg3 ;
92472   float result;
92473
92474   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92475   arg2 = (float)jarg2;
92476   arg3 = (float)jarg3;
92477   {
92478     try {
92479       result = (float)(*arg1)->Snap(arg2,arg3);
92480     } catch (std::out_of_range& e) {
92481       {
92482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92483       };
92484     } catch (std::exception& e) {
92485       {
92486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92487       };
92488     } catch (...) {
92489       {
92490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92491       };
92492     }
92493   }
92494   jresult = result;
92495   return jresult;
92496 }
92497
92498
92499 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92500   float jresult ;
92501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92502   float arg2 ;
92503   float result;
92504
92505   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92506   arg2 = (float)jarg2;
92507   {
92508     try {
92509       result = (float)(*arg1)->Snap(arg2);
92510     } catch (std::out_of_range& e) {
92511       {
92512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92513       };
92514     } catch (std::exception& e) {
92515       {
92516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92517       };
92518     } catch (...) {
92519       {
92520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92521       };
92522     }
92523   }
92524   jresult = result;
92525   return jresult;
92526 }
92527
92528
92529 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92530   float jresult ;
92531   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92532   unsigned int arg2 ;
92533   unsigned int *arg3 = 0 ;
92534   bool arg4 ;
92535   float result;
92536
92537   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92538   arg2 = (unsigned int)jarg2;
92539   arg3 = (unsigned int *)jarg3;
92540   arg4 = jarg4 ? true : false;
92541   {
92542     try {
92543       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92555       };
92556     }
92557   }
92558   jresult = result;
92559   return jresult;
92560 }
92561
92562
92563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92564   unsigned int jresult ;
92565   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92566   float arg2 ;
92567   bool arg3 ;
92568   unsigned int result;
92569
92570   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92571   arg2 = (float)jarg2;
92572   arg3 = jarg3 ? true : false;
92573   {
92574     try {
92575       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92576     } catch (std::out_of_range& e) {
92577       {
92578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92579       };
92580     } catch (std::exception& e) {
92581       {
92582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (...) {
92585       {
92586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92587       };
92588     }
92589   }
92590   jresult = result;
92591   return jresult;
92592 }
92593
92594
92595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_GetTotalPages(void * jarg1) {
92596   unsigned int jresult ;
92597   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92598   unsigned int result;
92599
92600   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92601   {
92602     try {
92603       result = (unsigned int)(*arg1)->GetTotalPages();
92604     } catch (std::out_of_range& e) {
92605       {
92606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (std::exception& e) {
92609       {
92610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618   jresult = result;
92619   return jresult;
92620 }
92621
92622
92623 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RulerPtr_GetType(void * jarg1) {
92624   int jresult ;
92625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92626   Dali::Toolkit::Ruler::RulerType result;
92627
92628   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92629   {
92630     try {
92631       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92632     } catch (std::out_of_range& e) {
92633       {
92634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92635       };
92636     } catch (std::exception& e) {
92637       {
92638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92639       };
92640     } catch (...) {
92641       {
92642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92643       };
92644     }
92645   }
92646   jresult = (int)result;
92647   return jresult;
92648 }
92649
92650
92651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_NUI_RulerPtr_IsEnabled(void * jarg1) {
92652   unsigned int jresult ;
92653   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92654   bool result;
92655
92656   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92657   {
92658     try {
92659       result = (bool)(*arg1)->IsEnabled();
92660     } catch (std::out_of_range& e) {
92661       {
92662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92663       };
92664     } catch (std::exception& e) {
92665       {
92666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92667       };
92668     } catch (...) {
92669       {
92670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92671       };
92672     }
92673   }
92674   jresult = result;
92675   return jresult;
92676 }
92677
92678
92679 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Enable(void * jarg1) {
92680   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92681
92682   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92683   {
92684     try {
92685       (*arg1)->Enable();
92686     } catch (std::out_of_range& e) {
92687       {
92688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92689       };
92690     } catch (std::exception& e) {
92691       {
92692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92693       };
92694     } catch (...) {
92695       {
92696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92697       };
92698     }
92699   }
92700 }
92701
92702
92703 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Disable(void * jarg1) {
92704   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92705
92706   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92707   {
92708     try {
92709       (*arg1)->Disable();
92710     } catch (std::out_of_range& e) {
92711       {
92712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92713       };
92714     } catch (std::exception& e) {
92715       {
92716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92717       };
92718     } catch (...) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92721       };
92722     }
92723   }
92724 }
92725
92726
92727 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92729   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92730   Dali::Toolkit::RulerDomain *argp2 ;
92731
92732   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92733   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92734   if (!argp2) {
92735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92736     return ;
92737   }
92738   arg2 = *argp2;
92739   {
92740     try {
92741       (*arg1)->SetDomain(arg2);
92742     } catch (std::out_of_range& e) {
92743       {
92744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92745       };
92746     } catch (std::exception& e) {
92747       {
92748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92749       };
92750     } catch (...) {
92751       {
92752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92753       };
92754     }
92755   }
92756 }
92757
92758
92759 SWIGEXPORT void * SWIGSTDCALL CSharp_NUI_RulerPtr_GetDomain(void * jarg1) {
92760   void * jresult ;
92761   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92762   Dali::Toolkit::RulerDomain *result = 0 ;
92763
92764   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92765   {
92766     try {
92767       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92768     } catch (std::out_of_range& e) {
92769       {
92770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92771       };
92772     } catch (std::exception& e) {
92773       {
92774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92775       };
92776     } catch (...) {
92777       {
92778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92779       };
92780     }
92781   }
92782   jresult = (void *)result;
92783   return jresult;
92784 }
92785
92786
92787 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_DisableDomain(void * jarg1) {
92788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92789
92790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92791   {
92792     try {
92793       (*arg1)->DisableDomain();
92794     } catch (std::out_of_range& e) {
92795       {
92796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92797       };
92798     } catch (std::exception& e) {
92799       {
92800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92801       };
92802     } catch (...) {
92803       {
92804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92805       };
92806     }
92807   }
92808 }
92809
92810
92811 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92812   float jresult ;
92813   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92814   float arg2 ;
92815   float arg3 ;
92816   float arg4 ;
92817   float result;
92818
92819   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92820   arg2 = (float)jarg2;
92821   arg3 = (float)jarg3;
92822   arg4 = (float)jarg4;
92823   {
92824     try {
92825       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92826     } catch (std::out_of_range& e) {
92827       {
92828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92829       };
92830     } catch (std::exception& e) {
92831       {
92832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92833       };
92834     } catch (...) {
92835       {
92836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92837       };
92838     }
92839   }
92840   jresult = result;
92841   return jresult;
92842 }
92843
92844
92845 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92846   float jresult ;
92847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92848   float arg2 ;
92849   float arg3 ;
92850   float result;
92851
92852   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92853   arg2 = (float)jarg2;
92854   arg3 = (float)jarg3;
92855   {
92856     try {
92857       result = (float)(*arg1)->Clamp(arg2,arg3);
92858     } catch (std::out_of_range& e) {
92859       {
92860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92861       };
92862     } catch (std::exception& e) {
92863       {
92864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92865       };
92866     } catch (...) {
92867       {
92868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92869       };
92870     }
92871   }
92872   jresult = result;
92873   return jresult;
92874 }
92875
92876
92877 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92878   float jresult ;
92879   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92880   float arg2 ;
92881   float result;
92882
92883   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92884   arg2 = (float)jarg2;
92885   {
92886     try {
92887       result = (float)(*arg1)->Clamp(arg2);
92888     } catch (std::out_of_range& e) {
92889       {
92890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92891       };
92892     } catch (std::exception& e) {
92893       {
92894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92895       };
92896     } catch (...) {
92897       {
92898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92899       };
92900     }
92901   }
92902   jresult = result;
92903   return jresult;
92904 }
92905
92906
92907 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92908   float jresult ;
92909   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92910   float arg2 ;
92911   float arg3 ;
92912   float arg4 ;
92913   Dali::Toolkit::ClampState *arg5 = 0 ;
92914   float result;
92915
92916   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92917   arg2 = (float)jarg2;
92918   arg3 = (float)jarg3;
92919   arg4 = (float)jarg4;
92920   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92921   if (!arg5) {
92922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92923     return 0;
92924   }
92925   {
92926     try {
92927       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92928     } catch (std::out_of_range& e) {
92929       {
92930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92931       };
92932     } catch (std::exception& e) {
92933       {
92934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92935       };
92936     } catch (...) {
92937       {
92938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92939       };
92940     }
92941   }
92942   jresult = result;
92943   return jresult;
92944 }
92945
92946
92947 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92948   float jresult ;
92949   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92950   float arg2 ;
92951   float arg3 ;
92952   float arg4 ;
92953   float arg5 ;
92954   float result;
92955
92956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92957   arg2 = (float)jarg2;
92958   arg3 = (float)jarg3;
92959   arg4 = (float)jarg4;
92960   arg5 = (float)jarg5;
92961   {
92962     try {
92963       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92964     } catch (std::out_of_range& e) {
92965       {
92966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92967       };
92968     } catch (std::exception& e) {
92969       {
92970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92971       };
92972     } catch (...) {
92973       {
92974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92975       };
92976     }
92977   }
92978   jresult = result;
92979   return jresult;
92980 }
92981
92982
92983 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92984   float jresult ;
92985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92986   float arg2 ;
92987   float arg3 ;
92988   float arg4 ;
92989   float result;
92990
92991   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92992   arg2 = (float)jarg2;
92993   arg3 = (float)jarg3;
92994   arg4 = (float)jarg4;
92995   {
92996     try {
92997       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92998     } catch (std::out_of_range& e) {
92999       {
93000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93001       };
93002     } catch (std::exception& e) {
93003       {
93004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93005       };
93006     } catch (...) {
93007       {
93008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93009       };
93010     }
93011   }
93012   jresult = result;
93013   return jresult;
93014 }
93015
93016
93017 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93018   float jresult ;
93019   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93020   float arg2 ;
93021   float arg3 ;
93022   float result;
93023
93024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93025   arg2 = (float)jarg2;
93026   arg3 = (float)jarg3;
93027   {
93028     try {
93029       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93030     } catch (std::out_of_range& e) {
93031       {
93032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93033       };
93034     } catch (std::exception& e) {
93035       {
93036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93037       };
93038     } catch (...) {
93039       {
93040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93041       };
93042     }
93043   }
93044   jresult = result;
93045   return jresult;
93046 }
93047
93048
93049 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93050   float jresult ;
93051   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93052   float arg2 ;
93053   float result;
93054
93055   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93056   arg2 = (float)jarg2;
93057   {
93058     try {
93059       result = (float)(*arg1)->SnapAndClamp(arg2);
93060     } catch (std::out_of_range& e) {
93061       {
93062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93063       };
93064     } catch (std::exception& e) {
93065       {
93066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93067       };
93068     } catch (...) {
93069       {
93070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93071       };
93072     }
93073   }
93074   jresult = result;
93075   return jresult;
93076 }
93077
93078
93079 SWIGEXPORT float SWIGSTDCALL CSharp_NUI_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93080   float jresult ;
93081   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93082   float arg2 ;
93083   float arg3 ;
93084   float arg4 ;
93085   float arg5 ;
93086   Dali::Toolkit::ClampState *arg6 = 0 ;
93087   float result;
93088
93089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93090   arg2 = (float)jarg2;
93091   arg3 = (float)jarg3;
93092   arg4 = (float)jarg4;
93093   arg5 = (float)jarg5;
93094   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93095   if (!arg6) {
93096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93097     return 0;
93098   }
93099   {
93100     try {
93101       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93102     } catch (std::out_of_range& e) {
93103       {
93104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93105       };
93106     } catch (std::exception& e) {
93107       {
93108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93109       };
93110     } catch (...) {
93111       {
93112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93113       };
93114     }
93115   }
93116   jresult = result;
93117   return jresult;
93118 }
93119
93120
93121 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Reference(void * jarg1) {
93122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93123
93124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93125   {
93126     try {
93127       (*arg1)->Reference();
93128     } catch (std::out_of_range& e) {
93129       {
93130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93131       };
93132     } catch (std::exception& e) {
93133       {
93134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93135       };
93136     } catch (...) {
93137       {
93138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93139       };
93140     }
93141   }
93142 }
93143
93144
93145 SWIGEXPORT void SWIGSTDCALL CSharp_NUI_RulerPtr_Unreference(void * jarg1) {
93146   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93147
93148   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93149   {
93150     try {
93151       (*arg1)->Unreference();
93152     } catch (std::out_of_range& e) {
93153       {
93154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93155       };
93156     } catch (std::exception& e) {
93157       {
93158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93159       };
93160     } catch (...) {
93161       {
93162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93163       };
93164     }
93165   }
93166 }
93167
93168
93169 SWIGEXPORT int SWIGSTDCALL CSharp_NUI_RulerPtr_ReferenceCount(void * jarg1) {
93170   int jresult ;
93171   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93172   int result;
93173
93174   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93175   {
93176     try {
93177       result = (int)(*arg1)->ReferenceCount();
93178     } catch (std::out_of_range& e) {
93179       {
93180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (std::exception& e) {
93183       {
93184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93185       };
93186     } catch (...) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93189       };
93190     }
93191   }
93192   jresult = result;
93193   return jresult;
93194 }
93195
93196
93197 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
93198     return (Dali::RefObject *)jarg1;
93199 }
93200
93201 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_NUI_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
93202     return (Dali::SignalObserver *)jarg1;
93203 }
93204
93205 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_NUI_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
93206     return (Dali::ConnectionTrackerInterface *)jarg1;
93207 }
93208
93209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
93210     return (Dali::BaseHandle *)jarg1;
93211 }
93212
93213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
93214     return (Dali::BaseHandle *)jarg1;
93215 }
93216
93217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
93218     return (Dali::BaseHandle *)jarg1;
93219 }
93220
93221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Handle_SWIGUpcast(Dali::Handle *jarg1) {
93222     return (Dali::BaseHandle *)jarg1;
93223 }
93224
93225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
93226     return (Dali::BaseHandle *)jarg1;
93227 }
93228
93229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
93230     return (Dali::BaseHandle *)jarg1;
93231 }
93232
93233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Image_SWIGUpcast(Dali::Image *jarg1) {
93234     return (Dali::BaseHandle *)jarg1;
93235 }
93236
93237 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
93238     return (Dali::BaseHandle *)jarg1;
93239 }
93240
93241 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Texture_SWIGUpcast(Dali::Texture *jarg1) {
93242     return (Dali::BaseHandle *)jarg1;
93243 }
93244
93245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
93246     return (Dali::BaseHandle *)jarg1;
93247 }
93248
93249 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
93250     return (Dali::BaseHandle *)jarg1;
93251 }
93252
93253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93254     return (Dali::BaseHandle *)jarg1;
93255 }
93256
93257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93258     return (Dali::BaseHandle *)jarg1;
93259 }
93260
93261 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93262     return (Dali::Handle *)jarg1;
93263 }
93264
93265 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93266     return (Dali::Handle *)jarg1;
93267 }
93268
93269 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93270     return (Dali::BaseHandle *)jarg1;
93271 }
93272
93273 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93274     return (Dali::BaseHandle *)jarg1;
93275 }
93276
93277 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93278     return (Dali::Handle *)jarg1;
93279 }
93280
93281 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TouchData_SWIGUpcast(Dali::TouchData *jarg1) {
93282     return (Dali::BaseHandle *)jarg1;
93283 }
93284
93285 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93286     return (Dali::Handle *)jarg1;
93287 }
93288
93289 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93290     return (Dali::GestureDetector *)jarg1;
93291 }
93292
93293 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93294     return (Dali::Gesture *)jarg1;
93295 }
93296
93297 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93298     return (Dali::Handle *)jarg1;
93299 }
93300
93301 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93302     return (Dali::Actor *)jarg1;
93303 }
93304
93305 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93306     return (Dali::BaseHandle *)jarg1;
93307 }
93308
93309 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93310     return (Dali::RefObject *)jarg1;
93311 }
93312
93313 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93314     return (Dali::Actor *)jarg1;
93315 }
93316
93317 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93318     return (Dali::GestureDetector *)jarg1;
93319 }
93320
93321 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93322     return (Dali::Gesture *)jarg1;
93323 }
93324
93325 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93326     return (Dali::GestureDetector *)jarg1;
93327 }
93328
93329 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93330     return (Dali::Gesture *)jarg1;
93331 }
93332
93333 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_NUI_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93334     return (Dali::GestureDetector *)jarg1;
93335 }
93336
93337 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_NUI_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93338     return (Dali::Gesture *)jarg1;
93339 }
93340
93341 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93342     return (Dali::BaseHandle *)jarg1;
93343 }
93344
93345 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_Path_SWIGUpcast(Dali::Path *jarg1) {
93346     return (Dali::Handle *)jarg1;
93347 }
93348
93349 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93350     return (Dali::BaseHandle *)jarg1;
93351 }
93352
93353 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93354     return (Dali::Handle *)jarg1;
93355 }
93356
93357 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_NUI_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93358     return (Dali::Handle *)jarg1;
93359 }
93360
93361 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93362     return (Dali::Image *)jarg1;
93363 }
93364
93365 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93366     return (Dali::Image *)jarg1;
93367 }
93368
93369 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93370     return (Dali::Image *)jarg1;
93371 }
93372
93373 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93374     return (Dali::RefObject *)jarg1;
93375 }
93376
93377 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93378     return (Dali::Image *)jarg1;
93379 }
93380
93381 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_NUI_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93382     return (Dali::Image *)jarg1;
93383 }
93384
93385 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_NUI_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93386     return (Dali::ResourceImage *)jarg1;
93387 }
93388
93389 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_NUI_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93390     return (Dali::Actor *)jarg1;
93391 }
93392
93393 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93394     return (Dali::BaseHandle *)jarg1;
93395 }
93396
93397 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93398     return (Dali::BaseHandle *)jarg1;
93399 }
93400
93401 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Window_SWIGUpcast(Dali::Window *jarg1) {
93402     return (Dali::BaseHandle *)jarg1;
93403 }
93404
93405 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Application_SWIGUpcast(Dali::Application *jarg1) {
93406     return (Dali::BaseHandle *)jarg1;
93407 }
93408
93409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93410     return (Dali::BaseHandle *)jarg1;
93411 }
93412
93413 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93414     return (Dali::BaseHandle *)jarg1;
93415 }
93416
93417 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_NUI_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93418     return (Dali::CustomActorImpl *)jarg1;
93419 }
93420
93421 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_NUI_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93422     return (Dali::CustomActor *)jarg1;
93423 }
93424
93425 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93426     return (Dali::BaseHandle *)jarg1;
93427 }
93428
93429 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93430     return (Dali::Toolkit::Control *)jarg1;
93431 }
93432
93433 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93434     return (Dali::Toolkit::Control *)jarg1;
93435 }
93436
93437 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93438     return (Dali::Toolkit::Button *)jarg1;
93439 }
93440
93441 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93442     return (Dali::Toolkit::Button *)jarg1;
93443 }
93444
93445 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_NUI_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93446     return (Dali::Toolkit::Button *)jarg1;
93447 }
93448
93449 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93450     return (Dali::Toolkit::Control *)jarg1;
93451 }
93452
93453 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93454     return (Dali::Toolkit::Control *)jarg1;
93455 }
93456
93457 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93458     return (Dali::Toolkit::Control *)jarg1;
93459 }
93460
93461 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93462     return (Dali::Toolkit::Control *)jarg1;
93463 }
93464
93465 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93466     return (Dali::Toolkit::Control *)jarg1;
93467 }
93468
93469 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93470     return (Dali::RefObject *)jarg1;
93471 }
93472
93473 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_NUI_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93474     return (Dali::Toolkit::Scrollable *)jarg1;
93475 }
93476
93477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93478     return (Dali::BaseHandle *)jarg1;
93479 }
93480
93481 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_NUI_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93482     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93483 }
93484
93485 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_NUI_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93486     return (Dali::RefObject *)jarg1;
93487 }
93488
93489 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_NUI_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93490     return (Dali::Toolkit::Ruler *)jarg1;
93491 }
93492
93493 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_NUI_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93494     return (Dali::Toolkit::Ruler *)jarg1;
93495 }
93496
93497 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_NUI_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93498     return (Dali::Toolkit::Scrollable *)jarg1;
93499 }
93500
93501 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93502     return (Dali::Toolkit::Control *)jarg1;
93503 }
93504
93505 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93506     return (Dali::Toolkit::Control *)jarg1;
93507 }
93508
93509 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93510     return (Dali::Toolkit::Control *)jarg1;
93511 }
93512
93513 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93514     return (Dali::Toolkit::Control *)jarg1;
93515 }
93516
93517 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93518     return (Dali::BaseHandle *)jarg1;
93519 }
93520
93521 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93522     return (Dali::BaseHandle *)jarg1;
93523 }
93524
93525 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93526     return (Dali::Toolkit::Control *)jarg1;
93527 }
93528
93529 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93530     return (Dali::Toolkit::Control *)jarg1;
93531 }
93532
93533 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93534     return (Dali::Toolkit::Control *)jarg1;
93535 }
93536
93537 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93538     return (Dali::Toolkit::Control *)jarg1;
93539 }
93540
93541 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93542     return (Dali::Toolkit::Control *)jarg1;
93543 }
93544
93545 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_NUI_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93546     return (Dali::Toolkit::Control *)jarg1;
93547 }
93548
93549 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_NUI_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93550     return (Dali::Toolkit::PageTurnView *)jarg1;
93551 }
93552
93553 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_NUI_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93554     return (Dali::Toolkit::PageTurnView *)jarg1;
93555 }
93556
93557 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93558     return (Dali::BaseHandle *)jarg1;
93559 }
93560
93561 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93562     return (Dali::BaseHandle *)jarg1;
93563 }
93564
93565 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_NUI_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93566     return (Dali::BaseHandle *)jarg1;
93567 }
93568
93569 #ifdef __cplusplus
93570 }
93571 #endif
93572