dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429 #include <dali/devel-api/events/wheel-event-devel.h>
 430 #include <dali/devel-api/events/key-event-devel.h>
 431
 432 #include <dali/public-api/math/matrix.h>
 433 #include <dali/public-api/math/matrix3.h>
 434 #include <dali/public-api/math/viewport.h>
 435 #include <dali/public-api/object/property-key.h>
 436 #include <dali/devel-api/object/csharp-type-info.h>
 437 #include <dali/devel-api/object/csharp-type-registry.h>
 438
 439 #include <dali/public-api/adaptor-framework/timer.h>
 440 #include <dali/public-api/adaptor-framework/style-change.h>
 441 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 442
 443 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/control-devel.h>
 451 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 459 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 460 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 461
 462 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 463 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 464 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 465
 466 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 467 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 469
 470 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 471 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 472 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 473
 474 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 475
 476 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 477 #include <dali/devel-api/adaptor-framework/image-loading.h>
 478
 479 #include <dali/public-api/events/mouse-button.h>
 480
 481 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 482 #include "web-view-signal-converter.h"
 483
 484 #include <dali/integration-api/debug.h>
 485
 486 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 487
 488 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 489
 490 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 491
 492
 493 #include <dali/devel-api/update/frame-callback-interface.h>
 494 #include <dali/devel-api/update/update-proxy.h>
 495
 496
 497 // add here SWIG version check
 498
 499 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 500 // disable Swig-dependent warnings
 501
 502 // 'identifier1' has C-linkage specified,
 503 // but returns UDT 'identifier2' which is incompatible with C
 504 #pragma warning(disable: 4190)
 505
 506 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 507 #pragma warning(disable: 4800)
 508
 509 // debug info too long etc etc
 510 #pragma warning(disable: 4786)
 511 #endif
 512
 513
 514 #include <stdexcept>
 515
 516
 517 #include <string>
 518
 519
 520 #include <vector>
 521 #include <algorithm>
 522 #include <stdexcept>
 523
 524
 525 #include <map>
 526 #include <algorithm>
 527 #include <stdexcept>
 528
 529
 530 #include <utility>
 531
 532
 533 typedef float floatp;
 534
 535 SWIGINTERN floatp *new_floatp(){
 536   return new float();
 537 }
 538 SWIGINTERN void delete_floatp(floatp *self){
 539   if (self) delete self;
 540 }
 541 SWIGINTERN void floatp_assign(floatp *self,float value){
 542   *self = value;
 543 }
 544 SWIGINTERN float floatp_value(floatp *self){
 545   return *self;
 546 }
 547 SWIGINTERN float *floatp_cast(floatp *self){
 548   return self;
 549 }
 550 SWIGINTERN floatp *floatp_frompointer(float *t){
 551   return (floatp *) t;
 552 }
 553
 554 typedef int intp;
 555
 556 SWIGINTERN intp *new_intp(){
 557   return new int();
 558 }
 559 SWIGINTERN void delete_intp(intp *self){
 560   if (self) delete self;
 561 }
 562 SWIGINTERN void intp_assign(intp *self,int value){
 563   *self = value;
 564 }
 565 SWIGINTERN int intp_value(intp *self){
 566   return *self;
 567 }
 568 SWIGINTERN int *intp_cast(intp *self){
 569   return self;
 570 }
 571 SWIGINTERN intp *intp_frompointer(int *t){
 572   return (intp *) t;
 573 }
 574
 575 typedef double doublep;
 576
 577 SWIGINTERN doublep *new_doublep(){
 578   return new double();
 579 }
 580 SWIGINTERN void delete_doublep(doublep *self){
 581   if (self) delete self;
 582 }
 583 SWIGINTERN void doublep_assign(doublep *self,double value){
 584   *self = value;
 585 }
 586 SWIGINTERN double doublep_value(doublep *self){
 587   return *self;
 588 }
 589 SWIGINTERN double *doublep_cast(doublep *self){
 590   return self;
 591 }
 592 SWIGINTERN doublep *doublep_frompointer(double *t){
 593   return (doublep *) t;
 594 }
 595
 596 typedef unsigned int uintp;
 597
 598 SWIGINTERN uintp *new_uintp(){
 599   return new unsigned int();
 600 }
 601 SWIGINTERN void delete_uintp(uintp *self){
 602   if (self) delete self;
 603 }
 604 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 605   *self = value;
 606 }
 607 SWIGINTERN unsigned int uintp_value(uintp *self){
 608   return *self;
 609 }
 610 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 611   return self;
 612 }
 613 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 614   return (uintp *) t;
 615 }
 616
 617 typedef unsigned short ushortp;
 618
 619 SWIGINTERN ushortp *new_ushortp(){
 620   return new unsigned short();
 621 }
 622 SWIGINTERN void delete_ushortp(ushortp *self){
 623   if (self) delete self;
 624 }
 625 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 626   *self = value;
 627 }
 628 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 629   return *self;
 630 }
 631 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 632   return self;
 633 }
 634 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 635   return (ushortp *) t;
 636 }
 637
 638 unsigned int int_to_uint(int x) {
 639    return (unsigned int) x;
 640 }
 641
 642
 643 using namespace Dali;
 644 using namespace Dali::Toolkit;
 645
 646 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 647 {
 648   bool result = false;
 649   try
 650   {
 651     // C++ code. DALi uses Handle <-> Body design pattern.
 652     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 653     // Handles in DALi can be converted into a boolean type
 654     // to check if the handle has a valid body attached to it.
 655     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 656     if( *self )
 657     {
 658       result = true;
 659     }
 660     else
 661     {
 662       result = false;
 663     }
 664   }
 665   catch (std::out_of_range& e)
 666   {
 667     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 668     return 0;
 669   }
 670   catch (std::exception& e)
 671   {
 672     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 673     return 0;
 674   }
 675   catch (DaliException e)
 676   {
 677     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 678     return 0;
 679   }
 680   catch (...)
 681   {
 682     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 683     return 0;
 684   }
 685   return result;
 686 }
 687
 688 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 689 {
 690   bool result = false;
 691   try
 692   {
 693     // C++ code. Check if two handles reference the same implemtion
 694     if( *self == rhs)
 695     {
 696       result = true;
 697     }
 698     else
 699     {
 700       result = false;
 701     }
 702   }
 703   catch (std::out_of_range& e)
 704   {
 705     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 706     return 0;
 707   }
 708   catch (std::exception& e)
 709   {
 710     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 711     return 0;
 712   }
 713   catch (DaliException e)
 714   {
 715     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 716     return 0;
 717   }
 718   catch (...)
 719   {
 720     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 721     return 0;
 722   }
 723   return result;
 724 }
 725
 726
 727 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 728      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 729    }
 730 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 731      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 732    }
 733 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 734         std::vector< Dali::TouchPoint >* pv = 0;
 735         if (capacity >= 0) {
 736           pv = new std::vector< Dali::TouchPoint >();
 737           pv->reserve(capacity);
 738        } else {
 739           throw std::out_of_range("capacity");
 740        }
 741        return pv;
 742       }
 743 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 744         if (index>=0 && index<(int)self->size())
 745           return (*self)[index];
 746         else
 747           throw std::out_of_range("index");
 748       }
 749 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 750         if (index>=0 && index<(int)self->size())
 751           return (*self)[index];
 752         else
 753           throw std::out_of_range("index");
 754       }
 755 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 756         if (index>=0 && index<(int)self->size())
 757           (*self)[index] = val;
 758         else
 759           throw std::out_of_range("index");
 760       }
 761 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 762         self->insert(self->end(), values.begin(), values.end());
 763       }
 764 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 765         if (index < 0)
 766           throw std::out_of_range("index");
 767         if (count < 0)
 768           throw std::out_of_range("count");
 769         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 770           throw std::invalid_argument("invalid range");
 771         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 772       }
 773 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 774         if (index>=0 && index<(int)self->size()+1)
 775           self->insert(self->begin()+index, x);
 776         else
 777           throw std::out_of_range("index");
 778       }
 779 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 780         if (index>=0 && index<(int)self->size()+1)
 781           self->insert(self->begin()+index, values.begin(), values.end());
 782         else
 783           throw std::out_of_range("index");
 784       }
 785 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 786         if (index>=0 && index<(int)self->size())
 787           self->erase(self->begin() + index);
 788         else
 789           throw std::out_of_range("index");
 790       }
 791 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 792         if (index < 0)
 793           throw std::out_of_range("index");
 794         if (count < 0)
 795           throw std::out_of_range("count");
 796         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 797           throw std::invalid_argument("invalid range");
 798         self->erase(self->begin()+index, self->begin()+index+count);
 799       }
 800 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 801         if (count < 0)
 802           throw std::out_of_range("count");
 803         return new std::vector< Dali::TouchPoint >(count, value);
 804       }
 805 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 806         std::reverse(self->begin(), self->end());
 807       }
 808 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 809         if (index < 0)
 810           throw std::out_of_range("index");
 811         if (count < 0)
 812           throw std::out_of_range("count");
 813         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 814           throw std::invalid_argument("invalid range");
 815         std::reverse(self->begin()+index, self->begin()+index+count);
 816       }
 817 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 818         if (index < 0)
 819           throw std::out_of_range("index");
 820         if (index+values.size() > self->size())
 821           throw std::out_of_range("index");
 822         std::copy(values.begin(), values.end(), self->begin()+index);
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 841          return self->Empty();
 842       }
 843 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 844         return self->GetConnectionCount();
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 847           self->Connect( func );
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 850           self->Disconnect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 857          return self->Empty();
 858       }
 859 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){
 860         return self->GetConnectionCount();
 861       }
 862 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 *)){
 863           self->Connect( func );
 864       }
 865 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 *)){
 866           self->Disconnect( func );
 867       }
 868 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){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 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){
 889          return self->Empty();
 890       }
 891 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){
 892         return self->GetConnectionCount();
 893       }
 894 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 &)){
 895         self->Connect( func );
 896       }
 897 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 &)){
 898         self->Disconnect( func );
 899       }
 900 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){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 905          return self->Empty();
 906       }
 907 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 908         return self->GetConnectionCount();
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 911         self->Connect( func );
 912       }
 913 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 914         self->Disconnect( func );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 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){
 920          return self->Empty();
 921       }
 922 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){
 923         return self->GetConnectionCount();
 924       }
 925 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 &)){
 926         self->Connect( func );
 927       }
 928 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 &)){
 929         self->Disconnect( func );
 930       }
 931 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){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 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){
 935          return self->Empty();
 936       }
 937 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){
 938         return self->GetConnectionCount();
 939       }
 940 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 &)){
 941         self->Connect( func );
 942       }
 943 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 &)){
 944         self->Disconnect( func );
 945       }
 946 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){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972           self->Connect( func );
 973       }
 974 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 &)){
 975           self->Disconnect( func );
 976       }
 977 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){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 982          return self->Empty();
 983       }
 984 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 985         return self->GetConnectionCount();
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 988           self->Connect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 991           self->Disconnect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 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){
1001         return self->GetConnectionCount();
1002       }
1003 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 &)){
1004           self->Connect( func );
1005       }
1006 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 &)){
1007           self->Disconnect( func );
1008       }
1009 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){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 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){
1014          return self->Empty();
1015       }
1016 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){
1017         return self->GetConnectionCount();
1018       }
1019 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 &)){
1020         self->Connect( func );
1021       }
1022 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 &)){
1023         self->Disconnect( func );
1024       }
1025 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){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 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){
1030          return self->Empty();
1031       }
1032 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){
1033         return self->GetConnectionCount();
1034       }
1035 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 &)){
1036         self->Connect( func );
1037       }
1038 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 &)){
1039         self->Disconnect( func );
1040       }
1041 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){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 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){
1046          return self->Empty();
1047       }
1048 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){
1049         return self->GetConnectionCount();
1050       }
1051 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 &)){
1052         self->Connect( func );
1053       }
1054 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 &)){
1055         self->Disconnect( func );
1056       }
1057 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){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1068           return self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1074           self->Emit( arg1, arg3 );
1075       }
1076 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1077          return self->Empty();
1078       }
1079 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1080         return self->GetConnectionCount();
1081       }
1082 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1083           return self->Connect( func );
1084       }
1085 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1086           self->Disconnect( func );
1087       }
1088 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1089           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1090 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1091       }
1092
1093 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1094          return self->Empty();
1095       }
1096 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1097         return self->GetConnectionCount();
1098       }
1099 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1100           self->Connect( func );
1101       }
1102 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1103           self->Disconnect( func );
1104       }
1105 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1106           return self->Emit();
1107       }
1108
1109 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1110         std::vector< unsigned int >* pv = 0;
1111         if (capacity >= 0) {
1112           pv = new std::vector< unsigned int >();
1113           pv->reserve(capacity);
1114        } else {
1115           throw std::out_of_range("capacity");
1116        }
1117        return pv;
1118       }
1119 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1120         if (index>=0 && index<(int)self->size())
1121           return (*self)[index];
1122         else
1123           throw std::out_of_range("index");
1124       }
1125 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1126         if (index>=0 && index<(int)self->size())
1127           return (*self)[index];
1128         else
1129           throw std::out_of_range("index");
1130       }
1131 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1132         if (index>=0 && index<(int)self->size())
1133           (*self)[index] = val;
1134         else
1135           throw std::out_of_range("index");
1136       }
1137 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1138         self->insert(self->end(), values.begin(), values.end());
1139       }
1140 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1141         if (index < 0)
1142           throw std::out_of_range("index");
1143         if (count < 0)
1144           throw std::out_of_range("count");
1145         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1146           throw std::invalid_argument("invalid range");
1147         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1148       }
1149 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1150         if (index>=0 && index<(int)self->size()+1)
1151           self->insert(self->begin()+index, x);
1152         else
1153           throw std::out_of_range("index");
1154       }
1155 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1156         if (index>=0 && index<(int)self->size()+1)
1157           self->insert(self->begin()+index, values.begin(), values.end());
1158         else
1159           throw std::out_of_range("index");
1160       }
1161 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1162         if (index>=0 && index<(int)self->size())
1163           self->erase(self->begin() + index);
1164         else
1165           throw std::out_of_range("index");
1166       }
1167 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1168         if (index < 0)
1169           throw std::out_of_range("index");
1170         if (count < 0)
1171           throw std::out_of_range("count");
1172         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1173           throw std::invalid_argument("invalid range");
1174         self->erase(self->begin()+index, self->begin()+index+count);
1175       }
1176 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1177         if (count < 0)
1178           throw std::out_of_range("count");
1179         return new std::vector< unsigned int >(count, value);
1180       }
1181 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1182         std::reverse(self->begin(), self->end());
1183       }
1184 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1185         if (index < 0)
1186           throw std::out_of_range("index");
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1190           throw std::invalid_argument("invalid range");
1191         std::reverse(self->begin()+index, self->begin()+index+count);
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (index+values.size() > self->size())
1197           throw std::out_of_range("index");
1198         std::copy(values.begin(), values.end(), self->begin()+index);
1199       }
1200 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1201         return std::find(self->begin(), self->end(), value) != self->end();
1202       }
1203 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1204         int index = -1;
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end())
1207           index = (int)(it - self->begin());
1208         return index;
1209       }
1210 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1211         int index = -1;
1212         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1213         if (rit != self->rend())
1214           index = (int)(self->rend() - 1 - rit);
1215         return index;
1216       }
1217 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1218         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1219         if (it != self->end()) {
1220           self->erase(it);
1221           return true;
1222         }
1223         return false;
1224       }
1225 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){
1226         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1227         if (capacity >= 0) {
1228           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1229           pv->reserve(capacity);
1230        } else {
1231           throw std::out_of_range("capacity");
1232        }
1233        return pv;
1234       }
1235 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){
1236         if (index>=0 && index<(int)self->size())
1237           return (*self)[index];
1238         else
1239           throw std::out_of_range("index");
1240       }
1241 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){
1242         if (index>=0 && index<(int)self->size())
1243           return (*self)[index];
1244         else
1245           throw std::out_of_range("index");
1246       }
1247 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){
1248         if (index>=0 && index<(int)self->size())
1249           (*self)[index] = val;
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 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){
1254         self->insert(self->end(), values.begin(), values.end());
1255       }
1256 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){
1257         if (index < 0)
1258           throw std::out_of_range("index");
1259         if (count < 0)
1260           throw std::out_of_range("count");
1261         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1262           throw std::invalid_argument("invalid range");
1263         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1264       }
1265 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){
1266         if (index>=0 && index<(int)self->size()+1)
1267           self->insert(self->begin()+index, x);
1268         else
1269           throw std::out_of_range("index");
1270       }
1271 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){
1272         if (index>=0 && index<(int)self->size()+1)
1273           self->insert(self->begin()+index, values.begin(), values.end());
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 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){
1278         if (index>=0 && index<(int)self->size())
1279           self->erase(self->begin() + index);
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 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){
1284         if (index < 0)
1285           throw std::out_of_range("index");
1286         if (count < 0)
1287           throw std::out_of_range("count");
1288         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1289           throw std::invalid_argument("invalid range");
1290         self->erase(self->begin()+index, self->begin()+index+count);
1291       }
1292 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){
1293         if (count < 0)
1294           throw std::out_of_range("count");
1295         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1296       }
1297 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){
1298         std::reverse(self->begin(), self->end());
1299       }
1300 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){
1301         if (index < 0)
1302           throw std::out_of_range("index");
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1306           throw std::invalid_argument("invalid range");
1307         std::reverse(self->begin()+index, self->begin()+index+count);
1308       }
1309 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){
1310         if (index < 0)
1311           throw std::out_of_range("index");
1312         if (index+values.size() > self->size())
1313           throw std::out_of_range("index");
1314         std::copy(values.begin(), values.end(), self->begin()+index);
1315       }
1316 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1317         std::vector< Dali::Actor >* pv = 0;
1318         if (capacity >= 0) {
1319           pv = new std::vector< Dali::Actor >();
1320           pv->reserve(capacity);
1321        } else {
1322           throw std::out_of_range("capacity");
1323        }
1324        return pv;
1325       }
1326 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1327         if (index>=0 && index<(int)self->size())
1328           return (*self)[index];
1329         else
1330           throw std::out_of_range("index");
1331       }
1332 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1333         if (index>=0 && index<(int)self->size())
1334           return (*self)[index];
1335         else
1336           throw std::out_of_range("index");
1337       }
1338 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1339         if (index>=0 && index<(int)self->size())
1340           (*self)[index] = val;
1341         else
1342           throw std::out_of_range("index");
1343       }
1344 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1345         self->insert(self->end(), values.begin(), values.end());
1346       }
1347 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1348         if (index < 0)
1349           throw std::out_of_range("index");
1350         if (count < 0)
1351           throw std::out_of_range("count");
1352         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1353           throw std::invalid_argument("invalid range");
1354         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1355       }
1356 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1357         if (index>=0 && index<(int)self->size()+1)
1358           self->insert(self->begin()+index, x);
1359         else
1360           throw std::out_of_range("index");
1361       }
1362 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1363         if (index>=0 && index<(int)self->size()+1)
1364           self->insert(self->begin()+index, values.begin(), values.end());
1365         else
1366           throw std::out_of_range("index");
1367       }
1368 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1369         if (index>=0 && index<(int)self->size())
1370           self->erase(self->begin() + index);
1371         else
1372           throw std::out_of_range("index");
1373       }
1374 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1375         if (index < 0)
1376           throw std::out_of_range("index");
1377         if (count < 0)
1378           throw std::out_of_range("count");
1379         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1380           throw std::invalid_argument("invalid range");
1381         self->erase(self->begin()+index, self->begin()+index+count);
1382       }
1383 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1384         if (count < 0)
1385           throw std::out_of_range("count");
1386         return new std::vector< Dali::Actor >(count, value);
1387       }
1388 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1389         std::reverse(self->begin(), self->end());
1390       }
1391 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1392         if (index < 0)
1393           throw std::out_of_range("index");
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1397           throw std::invalid_argument("invalid range");
1398         std::reverse(self->begin()+index, self->begin()+index+count);
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1401         if (index < 0)
1402           throw std::out_of_range("index");
1403         if (index+values.size() > self->size())
1404           throw std::out_of_range("index");
1405         std::copy(values.begin(), values.end(), self->begin()+index);
1406       }
1407 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1408          return self->Empty();
1409       }
1410 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1411         return self->GetConnectionCount();
1412       }
1413 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 &)){
1414           self->Connect( func );
1415       }
1416 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 &)){
1417           self->Disconnect( func );
1418       }
1419 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){
1420           return self->Emit( arg );
1421       }
1422 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){
1423          return self->Empty();
1424       }
1425 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){
1426         return self->GetConnectionCount();
1427       }
1428 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)){
1429         self->Connect( func );
1430       }
1431 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)){
1432         self->Disconnect( func );
1433       }
1434 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){
1435         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1436 /*@SWIG@*/ self->Emit( arg1, arg2 );
1437       }
1438 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1439          return self->Empty();
1440       }
1441 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){
1442         return self->GetConnectionCount();
1443       }
1444 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)){
1445         self->Connect( func );
1446       }
1447 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)){
1448         self->Disconnect( func );
1449       }
1450 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){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1455          return self->Empty();
1456       }
1457 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1458         return self->GetConnectionCount();
1459       }
1460 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)){
1461         self->Connect( func );
1462       }
1463 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)){
1464         self->Disconnect( func );
1465       }
1466 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){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 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){
1471          return self->Empty();
1472       }
1473 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){
1474         return self->GetConnectionCount();
1475       }
1476 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)){
1477         self->Connect( func );
1478       }
1479 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)){
1480         self->Disconnect( func );
1481       }
1482 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){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1487          return self->Empty();
1488       }
1489 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1490         return self->GetConnectionCount();
1491       }
1492 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)){
1493           self->Connect( func );
1494       }
1495 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)){
1496           self->Disconnect( func );
1497       }
1498 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1499           return self->Emit( arg );
1500       }
1501 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1502          return self->Empty();
1503       }
1504 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1505         return self->GetConnectionCount();
1506       }
1507 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)){
1508           self->Connect( func );
1509       }
1510 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)){
1511           self->Disconnect( func );
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1514           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1515 /*@SWIG@*/ self->Emit( arg );
1516       }
1517 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){
1518          return self->Empty();
1519       }
1520 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){
1521         return self->GetConnectionCount();
1522       }
1523 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)){
1524           return self->Connect( func );
1525       }
1526 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)){
1527           self->Disconnect( func );
1528       }
1529 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){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1532       }
1533 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1534          return self->Empty();
1535       }
1536 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1537         return self->GetConnectionCount();
1538       }
1539 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)){
1540           self->Connect( func );
1541       }
1542 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)){
1543           self->Disconnect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1556           return self->Connect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1564       }
1565 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){
1566          return self->Empty();
1567       }
1568 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){
1569         return self->GetConnectionCount();
1570       }
1571 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 &)){
1572           self->Connect( func );
1573       }
1574 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 &)){
1575           self->Disconnect( func );
1576       }
1577 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){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg );
1580       }
1581 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1582          return self->Empty();
1583       }
1584 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){
1585         return self->GetConnectionCount();
1586       }
1587 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 &)){
1588           self->Connect( func );
1589       }
1590 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 &)){
1591           self->Disconnect( func );
1592       }
1593 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){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597
1598
1599 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){
1600          return self->Empty();
1601       }
1602 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){
1603         return self->GetConnectionCount();
1604       }
1605 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 &)){
1606         self->Connect( func );
1607       }
1608 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 &)){
1609         self->Disconnect( func );
1610       }
1611 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){
1612         return self->Emit( arg1, arg2 );
1613       }
1614 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1615          return self->Empty();
1616       }
1617 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1618         return self->GetConnectionCount();
1619       }
1620 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)){
1621           self->Connect( func );
1622       }
1623 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)){
1624           self->Disconnect( func );
1625       }
1626 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1627           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1628 /*@SWIG@*/ self->Emit( arg );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 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 &)){
1637           self->Connect( func );
1638       }
1639 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 &)){
1640           self->Disconnect( func );
1641       }
1642 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){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1647          return self->Empty();
1648       }
1649 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){
1650         return self->GetConnectionCount();
1651       }
1652 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)){
1653         self->Connect( func );
1654       }
1655 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)){
1656         self->Disconnect( func );
1657       }
1658 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){
1659         return self->Emit( arg1, arg2 );
1660       }
1661 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1662          return self->Empty();
1663       }
1664 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){
1665         return self->GetConnectionCount();
1666       }
1667 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)){
1668         self->Connect( func );
1669       }
1670 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)){
1671         self->Disconnect( func );
1672       }
1673 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){
1674         return self->Emit( arg1, arg2 );
1675       }
1676
1677 /* ---------------------------------------------------
1678  * C++ director class methods
1679  * --------------------------------------------------- */
1680
1681 #include "dali_wrap.h"
1682
1683 /*
1684  *  Widget director
1685  */
1686 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1687   swig_init_callbacks();
1688 }
1689
1690 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1691 }
1692
1693 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1694   char * jcontentInfo = 0 ;
1695   void * jwindow  ;
1696
1697   if (!swig_callbackOnCreate) {
1698     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1699     return;
1700   } else {
1701     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1702     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1703     swig_callbackOnCreate(jcontentInfo, jwindow);
1704   }
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1708   char * jcontentInfo = 0 ;
1709   int jtype  ;
1710
1711   if (!swig_callbackOnTerminate) {
1712     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1713     return;
1714   } else {
1715     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1716     jtype = (int)type;
1717     swig_callbackOnTerminate(jcontentInfo, jtype);
1718   }
1719 }
1720
1721 void SwigDirector_WidgetImpl::OnPause() {
1722   if (!swig_callbackOnPause) {
1723     Dali::Internal::Adaptor::Widget::OnPause();
1724     return;
1725   } else {
1726     swig_callbackOnPause();
1727   }
1728 }
1729
1730 void SwigDirector_WidgetImpl::OnResume() {
1731   if (!swig_callbackOnResume) {
1732     Dali::Internal::Adaptor::Widget::OnResume();
1733     return;
1734   } else {
1735     swig_callbackOnResume();
1736   }
1737 }
1738
1739 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1740   void * jwindow  ;
1741
1742   if (!swig_callbackOnResize) {
1743     Dali::Internal::Adaptor::Widget::OnResize(window);
1744     return;
1745   } else {
1746     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1747     swig_callbackOnResize(jwindow);
1748   }
1749 }
1750
1751 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1752   char * jcontentInfo = 0 ;
1753   int jforce  ;
1754
1755   if (!swig_callbackOnUpdate) {
1756     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1757     return;
1758   } else {
1759     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1760     jforce = force;
1761     swig_callbackOnUpdate(jcontentInfo, jforce);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1766   void * jslotObserver = 0 ;
1767   void * jcallback = 0 ;
1768
1769   if (!swig_callbackSignalConnected) {
1770     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1771     return;
1772   } else {
1773     jslotObserver = (void *) slotObserver;
1774     jcallback = (void *) callback;
1775     swig_callbackSignalConnected(jslotObserver, jcallback);
1776   }
1777 }
1778
1779 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1780   void * jslotObserver = 0 ;
1781   void * jcallback = 0 ;
1782
1783   if (!swig_callbackSignalDisconnected) {
1784     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1785     return;
1786   } else {
1787     jslotObserver = (void *) slotObserver;
1788     jcallback = (void *) callback;
1789     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1790   }
1791 }
1792
1793 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1794
1795   swig_callbackOnCreate = callbackOnCreate;
1796   swig_callbackOnTerminate = callbackOnTerminate;
1797   swig_callbackOnPause = callbackOnPause;
1798   swig_callbackOnResume = callbackOnResume;
1799   swig_callbackOnResize = callbackOnResize;
1800   swig_callbackOnUpdate = callbackOnUpdate;
1801   swig_callbackSignalConnected = callbackSignalConnected;
1802   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1803 }
1804
1805 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1806   swig_callbackOnCreate = 0;
1807   swig_callbackOnTerminate = 0;
1808   swig_callbackOnPause = 0;
1809   swig_callbackOnResume = 0;
1810   swig_callbackOnResize = 0;
1811   swig_callbackOnUpdate = 0;
1812   swig_callbackSignalConnected = 0;
1813   swig_callbackSignalDisconnected = 0;
1814 }
1815
1816
1817 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1818   swig_init_callbacks();
1819 }
1820
1821 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1822
1823 }
1824
1825
1826 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1827   int jdepth  ;
1828
1829   if (!swig_callbackOnSceneConnection) {
1830     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1831     return;
1832   } else {
1833     jdepth = depth;
1834     swig_callbackOnSceneConnection(jdepth);
1835   }
1836 }
1837
1838 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1839   if (!swig_callbackOnSceneDisconnection) {
1840     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1841     return;
1842   } else {
1843     swig_callbackOnSceneDisconnection();
1844   }
1845 }
1846
1847 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1848   void * jchild = 0 ;
1849
1850   if (!swig_callbackOnChildAdd) {
1851     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1852     return;
1853   } else {
1854     jchild = (Dali::Actor *) &child;
1855     swig_callbackOnChildAdd(jchild);
1856   }
1857 }
1858
1859 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1860   void * jchild = 0 ;
1861
1862   if (!swig_callbackOnChildRemove) {
1863     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1864     return;
1865   } else {
1866     jchild = (Dali::Actor *) &child;
1867     swig_callbackOnChildRemove(jchild);
1868   }
1869 }
1870
1871 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1872   int jindex  ;
1873   void * jpropertyValue  ;
1874
1875   if (!swig_callbackOnPropertySet) {
1876     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1877     return;
1878   } else {
1879     jindex = index;
1880     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1881     swig_callbackOnPropertySet(jindex, jpropertyValue);
1882   }
1883 }
1884
1885 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1886   void * jtargetSize = 0 ;
1887
1888   if (!swig_callbackOnSizeSet) {
1889     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1890     return;
1891   } else {
1892     jtargetSize = (Dali::Vector3 *) &targetSize;
1893     swig_callbackOnSizeSet(jtargetSize);
1894   }
1895 }
1896
1897 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1898   void * janimation = 0 ;
1899   void * jtargetSize = 0 ;
1900
1901   if (!swig_callbackOnSizeAnimation) {
1902     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1903     return;
1904   } else {
1905     janimation = (Dali::Animation *) &animation;
1906     jtargetSize = (Dali::Vector3 *) &targetSize;
1907     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1908   }
1909 }
1910
1911 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1912   bool c_result = SwigValueInit< bool >() ;
1913   unsigned int jresult = 0 ;
1914   void * jarg0 = 0 ;
1915
1916   if (!swig_callbackOnHoverEvent) {
1917     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1918   } else {
1919     jarg0 = (Dali::HoverEvent *) &event;
1920     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1921     c_result = jresult ? true : false;
1922   }
1923   return c_result;
1924 }
1925
1926 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1927   bool c_result = SwigValueInit< bool >() ;
1928   unsigned int jresult = 0 ;
1929   void * jarg0 = 0 ;
1930
1931   if (!swig_callbackOnKeyEvent) {
1932     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1933   } else {
1934     jarg0 = (Dali::KeyEvent *) &event;
1935     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1936     c_result = jresult ? true : false;
1937   }
1938   return c_result;
1939 }
1940
1941 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1942   bool c_result = SwigValueInit< bool >() ;
1943   unsigned int jresult = 0 ;
1944   void * jarg0 = 0 ;
1945
1946   if (!swig_callbackOnWheelEvent) {
1947     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1948   } else {
1949     jarg0 = (Dali::WheelEvent *) &event;
1950     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1951     c_result = jresult ? true : false;
1952   }
1953   return c_result;
1954 }
1955
1956 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1957   void * jsize = 0 ;
1958   void * jcontainer = 0 ;
1959
1960   if (!swig_callbackOnRelayout) {
1961     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1962     return;
1963   } else {
1964     jsize = (Dali::Vector2 *) &size;
1965     jcontainer = (Dali::RelayoutContainer *) &container;
1966     swig_callbackOnRelayout(jsize, jcontainer);
1967   }
1968 }
1969
1970 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1971   int jpolicy  ;
1972   int jdimension  ;
1973
1974   if (!swig_callbackOnSetResizePolicy) {
1975     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1976     return;
1977   } else {
1978     jpolicy = (int)policy;
1979     jdimension = (int)dimension;
1980     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1981   }
1982 }
1983
1984 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1985   Dali::Vector3 c_result ;
1986   void * jresult = 0 ;
1987
1988   if (!swig_callbackGetNaturalSize) {
1989     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1990   } else {
1991     jresult = (void *) swig_callbackGetNaturalSize();
1992     if (!jresult) {
1993       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1994       return c_result;
1995     }
1996     c_result = *(Dali::Vector3 *)jresult;
1997   }
1998   return c_result;
1999 }
2000
2001 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2002   float c_result = SwigValueInit< float >() ;
2003   float jresult = 0 ;
2004   void * jchild = 0 ;
2005   int jdimension  ;
2006
2007   if (!swig_callbackCalculateChildSize) {
2008     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2009   } else {
2010     jchild = (Dali::Actor *) &child;
2011     jdimension = (int)dimension;
2012     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2013     c_result = (float)jresult;
2014   }
2015   return c_result;
2016 }
2017
2018 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2019   float c_result = SwigValueInit< float >() ;
2020   float jresult = 0 ;
2021   float jwidth  ;
2022
2023   if (!swig_callbackGetHeightForWidth) {
2024     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2025   } else {
2026     jwidth = width;
2027     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2028     c_result = (float)jresult;
2029   }
2030   return c_result;
2031 }
2032
2033 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2034   float c_result = SwigValueInit< float >() ;
2035   float jresult = 0 ;
2036   float jheight  ;
2037
2038   if (!swig_callbackGetWidthForHeight) {
2039     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2040   } else {
2041     jheight = height;
2042     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2043     c_result = (float)jresult;
2044   }
2045   return c_result;
2046 }
2047
2048 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2049   bool c_result = SwigValueInit< bool >() ;
2050   unsigned int jresult = 0 ;
2051   int jdimension  ;
2052
2053   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2054     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2055   } else {
2056     jdimension = (int)dimension;
2057     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2058     c_result = jresult ? true : false;
2059   }
2060   return c_result;
2061 }
2062
2063 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2064   int jdimension  ;
2065
2066   if (!swig_callbackOnCalculateRelayoutSize) {
2067     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2068     return;
2069   } else {
2070     jdimension = (int)dimension;
2071     swig_callbackOnCalculateRelayoutSize(jdimension);
2072   }
2073 }
2074
2075 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2076   float jsize  ;
2077   int jdimension  ;
2078
2079   if (!swig_callbackOnLayoutNegotiated) {
2080     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2081     return;
2082   } else {
2083     jsize = size;
2084     jdimension = (int)dimension;
2085     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2086   }
2087 }
2088
2089 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2090   return Dali::CustomActorImpl::GetExtension();
2091 }
2092
2093 void SwigDirector_ViewImpl::OnInitialize() {
2094   if (!swig_callbackOnInitialize) {
2095     Dali::Toolkit::Internal::Control::OnInitialize();
2096     return;
2097   } else {
2098     swig_callbackOnInitialize();
2099   }
2100 }
2101
2102 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2103   void * jstyleManager  ;
2104   int jchange  ;
2105
2106   if (!swig_callbackOnStyleChange) {
2107     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2108     return;
2109   } else {
2110     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2111     jchange = (int)change;
2112     swig_callbackOnStyleChange(jstyleManager, jchange);
2113   }
2114 }
2115
2116 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2117   bool c_result = SwigValueInit< bool >() ;
2118   unsigned int jresult = 0 ;
2119
2120   if (!swig_callbackOnAccessibilityActivated) {
2121     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2122   } else {
2123     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2124     c_result = jresult ? true : false;
2125   }
2126   return c_result;
2127 }
2128
2129 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2130   bool c_result = SwigValueInit< bool >() ;
2131   unsigned int jresult = 0 ;
2132   void * jgesture  ;
2133
2134   if (!swig_callbackOnAccessibilityPan) {
2135     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2136   } else {
2137     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2138     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2139     c_result = jresult ? true : false;
2140   }
2141   return c_result;
2142 }
2143
2144 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2145   bool c_result = SwigValueInit< bool >() ;
2146   unsigned int jresult = 0 ;
2147   unsigned int jisIncrease  ;
2148
2149   if (!swig_callbackOnAccessibilityValueChange) {
2150     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2151   } else {
2152     jisIncrease = isIncrease;
2153     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2154     c_result = jresult ? true : false;
2155   }
2156   return c_result;
2157 }
2158
2159 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2160   bool c_result = SwigValueInit< bool >() ;
2161   unsigned int jresult = 0 ;
2162
2163   if (!swig_callbackOnAccessibilityZoom) {
2164     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2165   } else {
2166     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2167     c_result = jresult ? true : false;
2168   }
2169   return c_result;
2170 }
2171
2172 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2173   if (!swig_callbackOnKeyInputFocusGained) {
2174     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2175     return;
2176   } else {
2177     swig_callbackOnKeyInputFocusGained();
2178   }
2179 }
2180
2181 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2182   if (!swig_callbackOnKeyInputFocusLost) {
2183     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2184     return;
2185   } else {
2186     swig_callbackOnKeyInputFocusLost();
2187   }
2188 }
2189
2190 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2191   Dali::Actor c_result ;
2192   void * jresult = 0 ;
2193   void * jcurrentFocusedActor  ;
2194   int jdirection  ;
2195   unsigned int jloopEnabled  ;
2196
2197   if (!swig_callbackGetNextKeyboardFocusableActor) {
2198     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2199   } else {
2200     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2201     jdirection = (int)direction;
2202     jloopEnabled = loopEnabled;
2203     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2204     if (!jresult) {
2205       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2206       return c_result;
2207     }
2208     c_result = *(Dali::Actor *)jresult;
2209   }
2210   return c_result;
2211 }
2212
2213 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2214   void * jcommitedFocusableActor  ;
2215
2216   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2217     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2218     return;
2219   } else {
2220     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2221     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2222   }
2223 }
2224
2225 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2226   bool c_result = SwigValueInit< bool >() ;
2227   unsigned int jresult = 0 ;
2228
2229   if (!swig_callbackOnKeyboardEnter) {
2230     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2231   } else {
2232     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2233     c_result = jresult ? true : false;
2234   }
2235   return c_result;
2236 }
2237
2238 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2239   void * jpinch = 0 ;
2240
2241   if (!swig_callbackOnPinch) {
2242     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2243     return;
2244   } else {
2245     jpinch = (Dali::PinchGesture *) &pinch;
2246     swig_callbackOnPinch(jpinch);
2247   }
2248 }
2249
2250 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2251   void * jpan = 0 ;
2252
2253   if (!swig_callbackOnPan) {
2254     Dali::Toolkit::Internal::Control::OnPan(pan);
2255     return;
2256   } else {
2257     jpan = (Dali::PanGesture *) &pan;
2258     swig_callbackOnPan(jpan);
2259   }
2260 }
2261
2262 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2263   void * jtap = 0 ;
2264
2265   if (!swig_callbackOnTap) {
2266     Dali::Toolkit::Internal::Control::OnTap(tap);
2267     return;
2268   } else {
2269     jtap = (Dali::TapGesture *) &tap;
2270     swig_callbackOnTap(jtap);
2271   }
2272 }
2273
2274 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2275   void * jlongPress = 0 ;
2276
2277   if (!swig_callbackOnLongPress) {
2278     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2279     return;
2280   } else {
2281     jlongPress = (Dali::LongPressGesture *) &longPress;
2282     swig_callbackOnLongPress(jlongPress);
2283   }
2284 }
2285
2286 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2287   void * jslotObserver = 0 ;
2288   void * jcallback = 0 ;
2289
2290   if (!swig_callbackSignalConnected) {
2291     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2292     return;
2293   } else {
2294     jslotObserver = (void *) slotObserver;
2295     jcallback = (void *) callback;
2296     swig_callbackSignalConnected(jslotObserver, jcallback);
2297   }
2298 }
2299
2300 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2301   void * jslotObserver = 0 ;
2302   void * jcallback = 0 ;
2303
2304   if (!swig_callbackSignalDisconnected) {
2305     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2306     return;
2307   } else {
2308     jslotObserver = (void *) slotObserver;
2309     jcallback = (void *) callback;
2310     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2311   }
2312 }
2313
2314 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2315   return Dali::Toolkit::Internal::Control::GetControlExtension();
2316 }
2317
2318 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, 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_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, 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) {
2319   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2320   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2321   swig_callbackOnChildAdd = callbackOnChildAdd;
2322   swig_callbackOnChildRemove = callbackOnChildRemove;
2323   swig_callbackOnPropertySet = callbackOnPropertySet;
2324   swig_callbackOnSizeSet = callbackOnSizeSet;
2325   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2326   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2327   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2328   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2329   swig_callbackOnRelayout = callbackOnRelayout;
2330   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2331   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2332   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2333   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2334   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2335   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2336   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2337   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2338   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2339   swig_callbackOnInitialize = callbackOnInitialize;
2340   swig_callbackOnStyleChange = callbackOnStyleChange;
2341   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2342   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2343   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2344   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2345   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2346   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2347   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2348   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2349   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2350   swig_callbackOnPinch = callbackOnPinch;
2351   swig_callbackOnPan = callbackOnPan;
2352   swig_callbackOnTap = callbackOnTap;
2353   swig_callbackOnLongPress = callbackOnLongPress;
2354   swig_callbackSignalConnected = callbackSignalConnected;
2355   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2356 }
2357
2358 void SwigDirector_ViewImpl::swig_init_callbacks() {
2359   swig_callbackOnSceneConnection = 0;
2360   swig_callbackOnSceneDisconnection = 0;
2361   swig_callbackOnChildAdd = 0;
2362   swig_callbackOnChildRemove = 0;
2363   swig_callbackOnPropertySet = 0;
2364   swig_callbackOnSizeSet = 0;
2365   swig_callbackOnSizeAnimation = 0;
2366   swig_callbackOnHoverEvent = 0;
2367   swig_callbackOnKeyEvent = 0;
2368   swig_callbackOnWheelEvent = 0;
2369   swig_callbackOnRelayout = 0;
2370   swig_callbackOnSetResizePolicy = 0;
2371   swig_callbackGetNaturalSize = 0;
2372   swig_callbackCalculateChildSize = 0;
2373   swig_callbackGetHeightForWidth = 0;
2374   swig_callbackGetWidthForHeight = 0;
2375   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2376   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2377   swig_callbackOnCalculateRelayoutSize = 0;
2378   swig_callbackOnLayoutNegotiated = 0;
2379   swig_callbackOnInitialize = 0;
2380   swig_callbackOnStyleChange = 0;
2381   swig_callbackOnAccessibilityActivated = 0;
2382   swig_callbackOnAccessibilityPan = 0;
2383   swig_callbackOnAccessibilityValueChange = 0;
2384   swig_callbackOnAccessibilityZoom = 0;
2385   swig_callbackOnKeyInputFocusGained = 0;
2386   swig_callbackOnKeyInputFocusLost = 0;
2387   swig_callbackGetNextKeyboardFocusableActor = 0;
2388   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2389   swig_callbackOnKeyboardEnter = 0;
2390   swig_callbackOnPinch = 0;
2391   swig_callbackOnPan = 0;
2392   swig_callbackOnTap = 0;
2393   swig_callbackOnLongPress = 0;
2394   swig_callbackSignalConnected = 0;
2395   swig_callbackSignalDisconnected = 0;
2396 }
2397
2398 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2399   swig_init_callbacks();
2400 }
2401
2402 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2403
2404 }
2405
2406
2407 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2408   unsigned int c_result = SwigValueInit< unsigned int >() ;
2409   unsigned int jresult = 0 ;
2410
2411   if (!swig_callbackGetNumberOfItems) {
2412     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2413   } else {
2414     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2415     c_result = (unsigned int)jresult;
2416   }
2417   return c_result;
2418 }
2419
2420 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2421   Dali::Actor c_result ;
2422   void * jresult = 0 ;
2423   unsigned int jitemId  ;
2424
2425   if (!swig_callbackNewItem) {
2426     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2427   } else {
2428     jitemId = itemId;
2429     jresult = (void *) swig_callbackNewItem(jitemId);
2430     if (!jresult) {
2431       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2432       return c_result;
2433     }
2434     c_result = *(Dali::Actor *)jresult;
2435   }
2436   return c_result;
2437 }
2438
2439 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2440   unsigned int jitemId  ;
2441   void * jactor  ;
2442
2443   if (!swig_callbackItemReleased) {
2444     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2445     return;
2446   } else {
2447     jitemId = itemId;
2448     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2449     swig_callbackItemReleased(jitemId, jactor);
2450   }
2451 }
2452
2453 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2454   return Dali::Toolkit::ItemFactory::GetExtension();
2455 }
2456
2457 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2458   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2459   swig_callbackNewItem = callbackNewItem;
2460   swig_callbackItemReleased = callbackItemReleased;
2461 }
2462
2463 void SwigDirector_ItemFactory::swig_init_callbacks() {
2464   swig_callbackGetNumberOfItems = 0;
2465   swig_callbackNewItem = 0;
2466   swig_callbackItemReleased = 0;
2467 }
2468
2469 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2470   swig_init_callbacks();
2471 }
2472
2473 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2474
2475 }
2476
2477
2478 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2479   Dali::Actor c_result ;
2480   void * jresult = 0 ;
2481   void * jcurrent  ;
2482   void * jproposed  ;
2483   int jdirection  ;
2484
2485   if (!swig_callbackGetNextFocusableActor) {
2486     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2487   } else {
2488     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2489     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2490     jdirection = (int)direction;
2491     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2492     if (!jresult) {
2493       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2494       return c_result;
2495     }
2496     c_result = *(Dali::Actor *)jresult;
2497   }
2498   return c_result;
2499 }
2500
2501 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2502   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2503 }
2504
2505 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2506   swig_callbackGetNextFocusableActor = 0;
2507 }
2508
2509 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2510   swig_callbackOnUpdate = 0;
2511 }
2512
2513 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2514
2515 }
2516
2517 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2518   swig_callbackOnUpdate = callbackUpdate;
2519 }
2520
2521
2522 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2523   void * jcurrent  ;
2524
2525   if (!swig_callbackOnUpdate) {
2526     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2527   } else {
2528     Dali::UpdateProxy* proxy = &updateProxy;
2529     jcurrent = (void *)proxy;
2530     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2531     if (!jcurrent) {
2532       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2533       return;
2534     }
2535   }
2536   return;
2537 }
2538
2539
2540 #ifdef __cplusplus
2541 extern "C" {
2542 #endif
2543
2544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2545   void * jresult ;
2546   floatp *result = 0 ;
2547
2548   {
2549     try {
2550       result = (floatp *)new_floatp();
2551     } catch (std::out_of_range& e) {
2552       {
2553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2554       };
2555     } catch (std::exception& e) {
2556       {
2557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2558       };
2559     } catch (DaliException e) {
2560       {
2561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2562       };
2563     } catch (...) {
2564       {
2565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2566       };
2567     }
2568   }
2569   jresult = (void *)result;
2570   return jresult;
2571 }
2572
2573
2574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2575   floatp *arg1 = (floatp *) 0 ;
2576
2577   arg1 = (floatp *)jarg1;
2578   {
2579     try {
2580       delete_floatp(arg1);
2581     } catch (std::out_of_range& e) {
2582       {
2583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2584       };
2585     } catch (std::exception& e) {
2586       {
2587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2588       };
2589     } catch (Dali::DaliException e) {
2590       {
2591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2592       };
2593     } catch (...) {
2594       {
2595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2596       };
2597     }
2598   }
2599
2600 }
2601
2602
2603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2604   floatp *arg1 = (floatp *) 0 ;
2605   float arg2 ;
2606
2607   arg1 = (floatp *)jarg1;
2608   arg2 = (float)jarg2;
2609   {
2610     try {
2611       floatp_assign(arg1,arg2);
2612     } catch (std::out_of_range& e) {
2613       {
2614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2615       };
2616     } catch (std::exception& e) {
2617       {
2618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2619       };
2620     } catch (Dali::DaliException e) {
2621       {
2622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2623       };
2624     } catch (...) {
2625       {
2626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2627       };
2628     }
2629   }
2630
2631 }
2632
2633
2634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2635   float jresult ;
2636   floatp *arg1 = (floatp *) 0 ;
2637   float result;
2638
2639   arg1 = (floatp *)jarg1;
2640   {
2641     try {
2642       result = (float)floatp_value(arg1);
2643     } catch (std::out_of_range& e) {
2644       {
2645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2646       };
2647     } catch (std::exception& e) {
2648       {
2649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2650       };
2651     } catch (DaliException e) {
2652       {
2653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2654       };
2655     } catch (...) {
2656       {
2657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2658       };
2659     }
2660   }
2661   jresult = result;
2662   return jresult;
2663 }
2664
2665
2666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2667   void * jresult ;
2668   floatp *arg1 = (floatp *) 0 ;
2669   float *result = 0 ;
2670
2671   arg1 = (floatp *)jarg1;
2672   {
2673     try {
2674       result = (float *)floatp_cast(arg1);
2675     } catch (std::out_of_range& e) {
2676       {
2677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2678       };
2679     } catch (std::exception& e) {
2680       {
2681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2682       };
2683     } catch (Dali::DaliException e) {
2684       {
2685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2690       };
2691     }
2692   }
2693
2694   jresult = (void *)result;
2695   return jresult;
2696 }
2697
2698
2699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2700   void * jresult ;
2701   float *arg1 = (float *) 0 ;
2702   floatp *result = 0 ;
2703
2704   arg1 = (float *)jarg1;
2705   {
2706     try {
2707       result = (floatp *)floatp_frompointer(arg1);
2708     } catch (std::out_of_range& e) {
2709       {
2710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2711       };
2712     } catch (std::exception& e) {
2713       {
2714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2715       };
2716     } catch (Dali::DaliException e) {
2717       {
2718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2719       };
2720     } catch (...) {
2721       {
2722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2723       };
2724     }
2725   }
2726
2727   jresult = (void *)result;
2728   return jresult;
2729 }
2730
2731
2732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2733   void * jresult ;
2734   intp *result = 0 ;
2735
2736   {
2737     try {
2738       result = (intp *)new_intp();
2739     } catch (std::out_of_range& e) {
2740       {
2741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2742       };
2743     } catch (std::exception& e) {
2744       {
2745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2746       };
2747     } catch (Dali::DaliException e) {
2748       {
2749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2750       };
2751     } catch (...) {
2752       {
2753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2754       };
2755     }
2756   }
2757
2758   jresult = (void *)result;
2759   return jresult;
2760 }
2761
2762
2763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2764   intp *arg1 = (intp *) 0 ;
2765
2766   arg1 = (intp *)jarg1;
2767   {
2768     try {
2769       delete_intp(arg1);
2770     } catch (std::out_of_range& e) {
2771       {
2772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2773       };
2774     } catch (std::exception& e) {
2775       {
2776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2777       };
2778     } catch (Dali::DaliException e) {
2779       {
2780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2781       };
2782     } catch (...) {
2783       {
2784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2785       };
2786     }
2787   }
2788
2789 }
2790
2791
2792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2793   intp *arg1 = (intp *) 0 ;
2794   int arg2 ;
2795
2796   arg1 = (intp *)jarg1;
2797   arg2 = (int)jarg2;
2798   {
2799     try {
2800       intp_assign(arg1,arg2);
2801     } catch (std::out_of_range& e) {
2802       {
2803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2804       };
2805     } catch (std::exception& e) {
2806       {
2807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2808       };
2809     } catch (Dali::DaliException e) {
2810       {
2811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2812       };
2813     } catch (...) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2816       };
2817     }
2818   }
2819
2820 }
2821
2822
2823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2824   int jresult ;
2825   intp *arg1 = (intp *) 0 ;
2826   int result;
2827
2828   arg1 = (intp *)jarg1;
2829   {
2830     try {
2831       result = (int)intp_value(arg1);
2832     } catch (std::out_of_range& e) {
2833       {
2834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2835       };
2836     } catch (std::exception& e) {
2837       {
2838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2839       };
2840     } catch (Dali::DaliException e) {
2841       {
2842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2843       };
2844     } catch (...) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2847       };
2848     }
2849   }
2850
2851   jresult = result;
2852   return jresult;
2853 }
2854
2855
2856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2857   void * jresult ;
2858   intp *arg1 = (intp *) 0 ;
2859   int *result = 0 ;
2860
2861   arg1 = (intp *)jarg1;
2862   {
2863     try {
2864       result = (int *)intp_cast(arg1);
2865     } catch (std::out_of_range& e) {
2866       {
2867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2868       };
2869     } catch (std::exception& e) {
2870       {
2871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2872       };
2873     } catch (Dali::DaliException e) {
2874       {
2875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2876       };
2877     } catch (...) {
2878       {
2879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2880       };
2881     }
2882   }
2883
2884   jresult = (void *)result;
2885   return jresult;
2886 }
2887
2888
2889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2890   void * jresult ;
2891   int *arg1 = (int *) 0 ;
2892   intp *result = 0 ;
2893
2894   arg1 = (int *)jarg1;
2895   {
2896     try {
2897       result = (intp *)intp_frompointer(arg1);
2898     } catch (std::out_of_range& e) {
2899       {
2900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2901       };
2902     } catch (std::exception& e) {
2903       {
2904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2905       };
2906     } catch (Dali::DaliException e) {
2907       {
2908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2909       };
2910     } catch (...) {
2911       {
2912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2913       };
2914     }
2915   }
2916
2917   jresult = (void *)result;
2918   return jresult;
2919 }
2920
2921
2922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2923   void * jresult ;
2924   doublep *result = 0 ;
2925
2926   {
2927     try {
2928       result = (doublep *)new_doublep();
2929     } catch (std::out_of_range& e) {
2930       {
2931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2932       };
2933     } catch (std::exception& e) {
2934       {
2935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2936       };
2937     } catch (Dali::DaliException e) {
2938       {
2939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2940       };
2941     } catch (...) {
2942       {
2943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2944       };
2945     }
2946   }
2947
2948   jresult = (void *)result;
2949   return jresult;
2950 }
2951
2952
2953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2954   doublep *arg1 = (doublep *) 0 ;
2955
2956   arg1 = (doublep *)jarg1;
2957   {
2958     try {
2959       delete_doublep(arg1);
2960     } catch (std::out_of_range& e) {
2961       {
2962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2963       };
2964     } catch (std::exception& e) {
2965       {
2966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2967       };
2968     } catch (Dali::DaliException e) {
2969       {
2970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2971       };
2972     } catch (...) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2975       };
2976     }
2977   }
2978
2979 }
2980
2981
2982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2983   doublep *arg1 = (doublep *) 0 ;
2984   double arg2 ;
2985
2986   arg1 = (doublep *)jarg1;
2987   arg2 = (double)jarg2;
2988   {
2989     try {
2990       doublep_assign(arg1,arg2);
2991     } catch (std::out_of_range& e) {
2992       {
2993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2994       };
2995     } catch (std::exception& e) {
2996       {
2997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2998       };
2999     } catch (Dali::DaliException e) {
3000       {
3001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3002       };
3003     } catch (...) {
3004       {
3005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3006       };
3007     }
3008   }
3009
3010 }
3011
3012
3013 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3014   double jresult ;
3015   doublep *arg1 = (doublep *) 0 ;
3016   double result;
3017
3018   arg1 = (doublep *)jarg1;
3019   {
3020     try {
3021       result = (double)doublep_value(arg1);
3022     } catch (std::out_of_range& e) {
3023       {
3024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3025       };
3026     } catch (std::exception& e) {
3027       {
3028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3029       };
3030     } catch (Dali::DaliException e) {
3031       {
3032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3033       };
3034     } catch (...) {
3035       {
3036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3037       };
3038     }
3039   }
3040
3041   jresult = result;
3042   return jresult;
3043 }
3044
3045
3046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3047   void * jresult ;
3048   doublep *arg1 = (doublep *) 0 ;
3049   double *result = 0 ;
3050
3051   arg1 = (doublep *)jarg1;
3052   {
3053     try {
3054       result = (double *)doublep_cast(arg1);
3055     } catch (std::out_of_range& e) {
3056       {
3057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3058       };
3059     } catch (std::exception& e) {
3060       {
3061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3062       };
3063     } catch (Dali::DaliException e) {
3064       {
3065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3066       };
3067     } catch (...) {
3068       {
3069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3070       };
3071     }
3072   }
3073
3074   jresult = (void *)result;
3075   return jresult;
3076 }
3077
3078
3079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3080   void * jresult ;
3081   double *arg1 = (double *) 0 ;
3082   doublep *result = 0 ;
3083
3084   arg1 = (double *)jarg1;
3085   {
3086     try {
3087       result = (doublep *)doublep_frompointer(arg1);
3088     } catch (std::out_of_range& e) {
3089       {
3090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3091       };
3092     } catch (std::exception& e) {
3093       {
3094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3095       };
3096     } catch (Dali::DaliException e) {
3097       {
3098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3099       };
3100     } catch (...) {
3101       {
3102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3103       };
3104     }
3105   }
3106
3107   jresult = (void *)result;
3108   return jresult;
3109 }
3110
3111
3112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3113   void * jresult ;
3114   uintp *result = 0 ;
3115
3116   {
3117     try {
3118       result = (uintp *)new_uintp();
3119     } catch (std::out_of_range& e) {
3120       {
3121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3122       };
3123     } catch (std::exception& e) {
3124       {
3125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3126       };
3127     } catch (Dali::DaliException e) {
3128       {
3129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3130       };
3131     } catch (...) {
3132       {
3133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3134       };
3135     }
3136   }
3137
3138   jresult = (void *)result;
3139   return jresult;
3140 }
3141
3142
3143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3144   uintp *arg1 = (uintp *) 0 ;
3145
3146   arg1 = (uintp *)jarg1;
3147   {
3148     try {
3149       delete_uintp(arg1);
3150     } catch (std::out_of_range& e) {
3151       {
3152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3153       };
3154     } catch (std::exception& e) {
3155       {
3156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3157       };
3158     } catch (Dali::DaliException e) {
3159       {
3160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3161       };
3162     } catch (...) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3165       };
3166     }
3167   }
3168
3169 }
3170
3171
3172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3173   uintp *arg1 = (uintp *) 0 ;
3174   unsigned int arg2 ;
3175
3176   arg1 = (uintp *)jarg1;
3177   arg2 = (unsigned int)jarg2;
3178   {
3179     try {
3180       uintp_assign(arg1,arg2);
3181     } catch (std::out_of_range& e) {
3182       {
3183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3184       };
3185     } catch (std::exception& e) {
3186       {
3187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3188       };
3189     } catch (Dali::DaliException e) {
3190       {
3191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3192       };
3193     } catch (...) {
3194       {
3195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3196       };
3197     }
3198   }
3199
3200 }
3201
3202
3203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3204   unsigned int jresult ;
3205   uintp *arg1 = (uintp *) 0 ;
3206   unsigned int result;
3207
3208   arg1 = (uintp *)jarg1;
3209   {
3210     try {
3211       result = (unsigned int)uintp_value(arg1);
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 (Dali::DaliException e) {
3221       {
3222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3223       };
3224     } catch (...) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3227       };
3228     }
3229   }
3230
3231   jresult = result;
3232   return jresult;
3233 }
3234
3235
3236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3237   void * jresult ;
3238   uintp *arg1 = (uintp *) 0 ;
3239   unsigned int *result = 0 ;
3240
3241   arg1 = (uintp *)jarg1;
3242   {
3243     try {
3244       result = (unsigned int *)uintp_cast(arg1);
3245     } catch (std::out_of_range& e) {
3246       {
3247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3248       };
3249     } catch (std::exception& e) {
3250       {
3251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3252       };
3253     } catch (Dali::DaliException e) {
3254       {
3255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3256       };
3257     } catch (...) {
3258       {
3259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3260       };
3261     }
3262   }
3263
3264   jresult = (void *)result;
3265   return jresult;
3266 }
3267
3268
3269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3270   void * jresult ;
3271   unsigned int *arg1 = (unsigned int *) 0 ;
3272   uintp *result = 0 ;
3273
3274   arg1 = (unsigned int *)jarg1;
3275   {
3276     try {
3277       result = (uintp *)uintp_frompointer(arg1);
3278     } catch (std::out_of_range& e) {
3279       {
3280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3281       };
3282     } catch (std::exception& e) {
3283       {
3284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3285       };
3286     } catch (Dali::DaliException e) {
3287       {
3288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3289       };
3290     } catch (...) {
3291       {
3292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3293       };
3294     }
3295   }
3296
3297   jresult = (void *)result;
3298   return jresult;
3299 }
3300
3301
3302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3303   void * jresult ;
3304   ushortp *result = 0 ;
3305
3306   {
3307     try {
3308       result = (ushortp *)new_ushortp();
3309     } catch (std::out_of_range& e) {
3310       {
3311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3312       };
3313     } catch (std::exception& e) {
3314       {
3315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3316       };
3317     } catch (Dali::DaliException e) {
3318       {
3319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3320       };
3321     } catch (...) {
3322       {
3323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3324       };
3325     }
3326   }
3327
3328   jresult = (void *)result;
3329   return jresult;
3330 }
3331
3332
3333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3334   ushortp *arg1 = (ushortp *) 0 ;
3335
3336   arg1 = (ushortp *)jarg1;
3337   {
3338     try {
3339       delete_ushortp(arg1);
3340     } catch (std::out_of_range& e) {
3341       {
3342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3343       };
3344     } catch (std::exception& e) {
3345       {
3346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3347       };
3348     } catch (Dali::DaliException e) {
3349       {
3350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3351       };
3352     } catch (...) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3355       };
3356     }
3357   }
3358
3359 }
3360
3361
3362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3363   ushortp *arg1 = (ushortp *) 0 ;
3364   unsigned short arg2 ;
3365
3366   arg1 = (ushortp *)jarg1;
3367   arg2 = (unsigned short)jarg2;
3368   {
3369     try {
3370       ushortp_assign(arg1,arg2);
3371     } catch (std::out_of_range& e) {
3372       {
3373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3374       };
3375     } catch (std::exception& e) {
3376       {
3377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3378       };
3379     } catch (Dali::DaliException e) {
3380       {
3381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3382       };
3383     } catch (...) {
3384       {
3385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3386       };
3387     }
3388   }
3389
3390 }
3391
3392
3393 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3394   unsigned short jresult ;
3395   ushortp *arg1 = (ushortp *) 0 ;
3396   unsigned short result;
3397
3398   arg1 = (ushortp *)jarg1;
3399   {
3400     try {
3401       result = (unsigned short)ushortp_value(arg1);
3402     } catch (std::out_of_range& e) {
3403       {
3404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3405       };
3406     } catch (std::exception& e) {
3407       {
3408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3409       };
3410     } catch (Dali::DaliException e) {
3411       {
3412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3413       };
3414     } catch (...) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3417       };
3418     }
3419   }
3420
3421   jresult = result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3427   void * jresult ;
3428   ushortp *arg1 = (ushortp *) 0 ;
3429   unsigned short *result = 0 ;
3430
3431   arg1 = (ushortp *)jarg1;
3432   {
3433     try {
3434       result = (unsigned short *)ushortp_cast(arg1);
3435     } catch (std::out_of_range& e) {
3436       {
3437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3438       };
3439     } catch (std::exception& e) {
3440       {
3441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3442       };
3443     } catch (Dali::DaliException e) {
3444       {
3445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3446       };
3447     } catch (...) {
3448       {
3449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3450       };
3451     }
3452   }
3453
3454   jresult = (void *)result;
3455   return jresult;
3456 }
3457
3458
3459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3460   void * jresult ;
3461   unsigned short *arg1 = (unsigned short *) 0 ;
3462   ushortp *result = 0 ;
3463
3464   arg1 = (unsigned short *)jarg1;
3465   {
3466     try {
3467       result = (ushortp *)ushortp_frompointer(arg1);
3468     } catch (std::out_of_range& e) {
3469       {
3470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3471       };
3472     } catch (std::exception& e) {
3473       {
3474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3475       };
3476     } catch (Dali::DaliException e) {
3477       {
3478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3479       };
3480     } catch (...) {
3481       {
3482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3483       };
3484     }
3485   }
3486
3487   jresult = (void *)result;
3488   return jresult;
3489 }
3490
3491
3492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3493   unsigned int jresult ;
3494   int arg1 ;
3495   unsigned int result;
3496
3497   arg1 = (int)jarg1;
3498   {
3499     try {
3500       result = (unsigned int)int_to_uint(arg1);
3501     } catch (std::out_of_range& e) {
3502       {
3503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3504       };
3505     } catch (std::exception& e) {
3506       {
3507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3508       };
3509     } catch (Dali::DaliException e) {
3510       {
3511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3512       };
3513     } catch (...) {
3514       {
3515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3516       };
3517     }
3518   }
3519
3520   jresult = result;
3521   return jresult;
3522 }
3523
3524
3525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3526   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3527
3528   arg1 = (Dali::RefObject *)jarg1;
3529   {
3530     try {
3531       (arg1)->Reference();
3532     } catch (std::out_of_range& e) {
3533       {
3534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3535       };
3536     } catch (std::exception& e) {
3537       {
3538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3539       };
3540     } catch (Dali::DaliException e) {
3541       {
3542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3543       };
3544     } catch (...) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3547       };
3548     }
3549   }
3550
3551 }
3552
3553
3554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3555   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3556
3557   arg1 = (Dali::RefObject *)jarg1;
3558   {
3559     try {
3560       (arg1)->Unreference();
3561     } catch (std::out_of_range& e) {
3562       {
3563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3564       };
3565     } catch (std::exception& e) {
3566       {
3567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3568       };
3569     } catch (Dali::DaliException e) {
3570       {
3571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3572       };
3573     } catch (...) {
3574       {
3575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3576       };
3577     }
3578   }
3579
3580 }
3581
3582
3583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3584   int jresult ;
3585   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3586   int result;
3587
3588   arg1 = (Dali::RefObject *)jarg1;
3589   {
3590     try {
3591       result = (int)(arg1)->ReferenceCount();
3592     } catch (std::out_of_range& e) {
3593       {
3594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3595       };
3596     } catch (std::exception& e) {
3597       {
3598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3599       };
3600     } catch (Dali::DaliException e) {
3601       {
3602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3603       };
3604     } catch (...) {
3605       {
3606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3607       };
3608     }
3609   }
3610
3611   jresult = result;
3612   return jresult;
3613 }
3614
3615
3616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3617   void * jresult ;
3618   Dali::Any *result = 0 ;
3619
3620   {
3621     try {
3622       result = (Dali::Any *)new Dali::Any();
3623     } catch (std::out_of_range& e) {
3624       {
3625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3626       };
3627     } catch (std::exception& e) {
3628       {
3629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3630       };
3631     } catch (Dali::DaliException e) {
3632       {
3633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3634       };
3635     } catch (...) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3638       };
3639     }
3640   }
3641
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3648   Dali::Any *arg1 = (Dali::Any *) 0 ;
3649
3650   arg1 = (Dali::Any *)jarg1;
3651   {
3652     try {
3653       delete arg1;
3654     } catch (std::out_of_range& e) {
3655       {
3656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3657       };
3658     } catch (std::exception& e) {
3659       {
3660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3661       };
3662     } catch (Dali::DaliException e) {
3663       {
3664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3665       };
3666     } catch (...) {
3667       {
3668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3669       };
3670     }
3671   }
3672
3673 }
3674
3675
3676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3677   char *arg1 = (char *) 0 ;
3678
3679   arg1 = (char *)jarg1;
3680   {
3681     try {
3682       Dali::Any::AssertAlways((char const *)arg1);
3683     } catch (std::out_of_range& e) {
3684       {
3685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3686       };
3687     } catch (std::exception& e) {
3688       {
3689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3690       };
3691     } catch (Dali::DaliException e) {
3692       {
3693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3694       };
3695     } catch (...) {
3696       {
3697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3698       };
3699     }
3700   }
3701
3702 }
3703
3704
3705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3706   void * jresult ;
3707   Dali::Any *arg1 = 0 ;
3708   Dali::Any *result = 0 ;
3709
3710   arg1 = (Dali::Any *)jarg1;
3711   if (!arg1) {
3712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3713     return 0;
3714   }
3715   {
3716     try {
3717       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3718     } catch (std::out_of_range& e) {
3719       {
3720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3721       };
3722     } catch (std::exception& e) {
3723       {
3724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3725       };
3726     } catch (Dali::DaliException e) {
3727       {
3728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3729       };
3730     } catch (...) {
3731       {
3732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3733       };
3734     }
3735   }
3736
3737   jresult = (void *)result;
3738   return jresult;
3739 }
3740
3741
3742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3743   void * jresult ;
3744   Dali::Any *arg1 = (Dali::Any *) 0 ;
3745   Dali::Any *arg2 = 0 ;
3746   Dali::Any *result = 0 ;
3747
3748   arg1 = (Dali::Any *)jarg1;
3749   arg2 = (Dali::Any *)jarg2;
3750   if (!arg2) {
3751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3752     return 0;
3753   }
3754   {
3755     try {
3756       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3757     } catch (std::out_of_range& e) {
3758       {
3759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3760       };
3761     } catch (std::exception& e) {
3762       {
3763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3764       };
3765     } catch (Dali::DaliException e) {
3766       {
3767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3768       };
3769     } catch (...) {
3770       {
3771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3772       };
3773     }
3774   }
3775
3776   jresult = (void *)result;
3777   return jresult;
3778 }
3779
3780
3781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3782   void * jresult ;
3783   Dali::Any *arg1 = (Dali::Any *) 0 ;
3784   std::type_info *result = 0 ;
3785
3786   arg1 = (Dali::Any *)jarg1;
3787   {
3788     try {
3789       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3790     } catch (std::out_of_range& e) {
3791       {
3792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3793       };
3794     } catch (std::exception& e) {
3795       {
3796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3797       };
3798     } catch (Dali::DaliException e) {
3799       {
3800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3801       };
3802     } catch (...) {
3803       {
3804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3805       };
3806     }
3807   }
3808
3809   jresult = (void *)result;
3810   return jresult;
3811 }
3812
3813
3814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3815   unsigned int jresult ;
3816   Dali::Any *arg1 = (Dali::Any *) 0 ;
3817   bool result;
3818
3819   arg1 = (Dali::Any *)jarg1;
3820   {
3821     try {
3822       result = (bool)((Dali::Any const *)arg1)->Empty();
3823     } catch (std::out_of_range& e) {
3824       {
3825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3826       };
3827     } catch (std::exception& e) {
3828       {
3829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3830       };
3831     } catch (Dali::DaliException e) {
3832       {
3833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3834       };
3835     } catch (...) {
3836       {
3837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3838       };
3839     }
3840   }
3841
3842   jresult = result;
3843   return jresult;
3844 }
3845
3846
3847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3848   void * jresult ;
3849   std::type_info *arg1 = 0 ;
3850   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3851   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3852   Dali::Any::AnyContainerBase *result = 0 ;
3853
3854   arg1 = (std::type_info *)jarg1;
3855   if (!arg1) {
3856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3857     return 0;
3858   }
3859   arg2 = (Dali::Any::CloneFunc)jarg2;
3860   arg3 = (Dali::Any::DeleteFunc)jarg3;
3861   {
3862     try {
3863       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3864     } catch (std::out_of_range& e) {
3865       {
3866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3867       };
3868     } catch (std::exception& e) {
3869       {
3870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (Dali::DaliException e) {
3873       {
3874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3875       };
3876     } catch (...) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3879       };
3880     }
3881   }
3882
3883   jresult = (void *)result;
3884   return jresult;
3885 }
3886
3887
3888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3889   void * jresult ;
3890   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3891   std::type_info *result = 0 ;
3892
3893   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3894   {
3895     try {
3896       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3897     } catch (std::out_of_range& e) {
3898       {
3899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3900       };
3901     } catch (std::exception& e) {
3902       {
3903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3904       };
3905     } catch (Dali::DaliException e) {
3906       {
3907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3908       };
3909     } catch (...) {
3910       {
3911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3912       };
3913     }
3914   }
3915
3916   jresult = (void *)result;
3917   return jresult;
3918 }
3919
3920
3921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3922   void * jresult ;
3923   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3924   ::std::type_info *result = 0 ;
3925
3926   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3927   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3934   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3935   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3936
3937   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3938   arg2 = (Dali::Any::CloneFunc)jarg2;
3939   if (arg1) (arg1)->mCloneFunc = arg2;
3940 }
3941
3942
3943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3944   void * jresult ;
3945   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3946   Dali::Any::CloneFunc result;
3947
3948   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3949   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3950   jresult = (void *)result;
3951   return jresult;
3952 }
3953
3954
3955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3956   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3957   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3958
3959   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3960   arg2 = (Dali::Any::DeleteFunc)jarg2;
3961   if (arg1) (arg1)->mDeleteFunc = arg2;
3962 }
3963
3964
3965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3966   void * jresult ;
3967   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3968   Dali::Any::DeleteFunc result;
3969
3970   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3971   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3972   jresult = (void *)result;
3973   return jresult;
3974 }
3975
3976
3977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3978   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3979
3980   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3981   {
3982     try {
3983       delete arg1;
3984     } catch (std::out_of_range& e) {
3985       {
3986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3987       };
3988     } catch (std::exception& e) {
3989       {
3990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3991       };
3992     } catch (Dali::DaliException e) {
3993       {
3994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3995       };
3996     } catch (...) {
3997       {
3998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3999       };
4000     }
4001   }
4002
4003 }
4004
4005
4006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4007   Dali::Any *arg1 = (Dali::Any *) 0 ;
4008   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4009
4010   arg1 = (Dali::Any *)jarg1;
4011   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4012   if (arg1) (arg1)->mContainer = arg2;
4013 }
4014
4015
4016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4017   void * jresult ;
4018   Dali::Any *arg1 = (Dali::Any *) 0 ;
4019   Dali::Any::AnyContainerBase *result = 0 ;
4020
4021   arg1 = (Dali::Any *)jarg1;
4022   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4023   jresult = (void *)result;
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4029   char *arg1 = (char *) 0 ;
4030   char *arg2 = (char *) 0 ;
4031
4032   arg1 = (char *)jarg1;
4033   arg2 = (char *)jarg2;
4034   {
4035     try {
4036       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4037     } catch (std::out_of_range& e) {
4038       {
4039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4040       };
4041     } catch (std::exception& e) {
4042       {
4043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4044       };
4045     } catch (Dali::DaliException e) {
4046       {
4047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4048       };
4049     } catch (...) {
4050       {
4051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4052       };
4053     }
4054   }
4055
4056 }
4057
4058
4059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4060   void * jresult ;
4061   char *arg1 = (char *) 0 ;
4062   char *arg2 = (char *) 0 ;
4063   Dali::DaliException *result = 0 ;
4064
4065   arg1 = (char *)jarg1;
4066   arg2 = (char *)jarg2;
4067   {
4068     try {
4069       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4070     } catch (std::out_of_range& e) {
4071       {
4072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4073       };
4074     } catch (std::exception& e) {
4075       {
4076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4077       };
4078     } catch (Dali::DaliException e) {
4079       {
4080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4081       };
4082     } catch (...) {
4083       {
4084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4085       };
4086     }
4087   }
4088
4089   jresult = (void *)result;
4090   return jresult;
4091 }
4092
4093
4094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4095   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4096   std::string arg2 = std::string(jarg2);
4097
4098   arg1 = (Dali::DaliException *)jarg1;
4099   {
4100     if (!arg2.empty()) {
4101       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4102     } else {
4103       arg1->location = 0;
4104     }
4105   }
4106 }
4107
4108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4109   char * jresult ;
4110   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4111   char *result = 0 ;
4112
4113   arg1 = (Dali::DaliException *)jarg1;
4114   result = (char *) ((arg1)->location);
4115   jresult = SWIG_csharp_string_callback((const char *)result);
4116   return jresult;
4117 }
4118
4119
4120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4121   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4122   std::string arg2 = std::string(jarg2);
4123
4124   arg1 = (Dali::DaliException *)jarg1;
4125   {
4126     if (!arg2.empty()) {
4127       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4128     } else {
4129       arg1->condition = 0;
4130     }
4131   }
4132 }
4133
4134
4135 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4136   char * jresult ;
4137   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4138   char *result = 0 ;
4139
4140   arg1 = (Dali::DaliException *)jarg1;
4141   result = (char *) ((arg1)->condition);
4142   jresult = SWIG_csharp_string_callback((const char *)result);
4143   return jresult;
4144 }
4145
4146
4147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4148   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4149
4150   arg1 = (Dali::DaliException *)jarg1;
4151   {
4152     try {
4153       delete arg1;
4154     } catch (std::out_of_range& e) {
4155       {
4156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4157       };
4158     } catch (std::exception& e) {
4159       {
4160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4161       };
4162     } catch (Dali::DaliException e) {
4163       {
4164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4165       };
4166     } catch (...) {
4167       {
4168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4169       };
4170     }
4171   }
4172
4173 }
4174
4175
4176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4177   void * jresult ;
4178   Dali::Vector2 *result = 0 ;
4179
4180   {
4181     try {
4182       result = (Dali::Vector2 *)new Dali::Vector2();
4183     } catch (std::out_of_range& e) {
4184       {
4185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4186       };
4187     } catch (std::exception& e) {
4188       {
4189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4190       };
4191     } catch (Dali::DaliException e) {
4192       {
4193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4194       };
4195     } catch (...) {
4196       {
4197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4198       };
4199     }
4200   }
4201
4202   jresult = (void *)result;
4203   return jresult;
4204 }
4205
4206
4207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4208   void * jresult ;
4209   float arg1 ;
4210   float arg2 ;
4211   Dali::Vector2 *result = 0 ;
4212
4213   arg1 = (float)jarg1;
4214   arg2 = (float)jarg2;
4215   {
4216     try {
4217       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4218     } catch (std::out_of_range& e) {
4219       {
4220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4221       };
4222     } catch (std::exception& e) {
4223       {
4224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4225       };
4226     } catch (Dali::DaliException e) {
4227       {
4228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4229       };
4230     } catch (...) {
4231       {
4232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4233       };
4234     }
4235   }
4236
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4243   void * jresult ;
4244   float *arg1 = (float *) 0 ;
4245   Dali::Vector2 *result = 0 ;
4246
4247   arg1 = jarg1;
4248   {
4249     try {
4250       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4251     } catch (std::out_of_range& e) {
4252       {
4253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4254       };
4255     } catch (std::exception& e) {
4256       {
4257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4258       };
4259     } catch (Dali::DaliException e) {
4260       {
4261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4262       };
4263     } catch (...) {
4264       {
4265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4266       };
4267     }
4268   }
4269
4270   jresult = (void *)result;
4271
4272
4273   return jresult;
4274 }
4275
4276
4277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4278   void * jresult ;
4279   Dali::Vector3 *arg1 = 0 ;
4280   Dali::Vector2 *result = 0 ;
4281
4282   arg1 = (Dali::Vector3 *)jarg1;
4283   if (!arg1) {
4284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4285     return 0;
4286   }
4287   {
4288     try {
4289       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4290     } catch (std::out_of_range& e) {
4291       {
4292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4293       };
4294     } catch (std::exception& e) {
4295       {
4296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (Dali::DaliException e) {
4299       {
4300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4301       };
4302     } catch (...) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4305       };
4306     }
4307   }
4308
4309   jresult = (void *)result;
4310   return jresult;
4311 }
4312
4313
4314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4315   void * jresult ;
4316   Dali::Vector4 *arg1 = 0 ;
4317   Dali::Vector2 *result = 0 ;
4318
4319   arg1 = (Dali::Vector4 *)jarg1;
4320   if (!arg1) {
4321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4322     return 0;
4323   }
4324   {
4325     try {
4326       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4327     } catch (std::out_of_range& e) {
4328       {
4329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4330       };
4331     } catch (std::exception& e) {
4332       {
4333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4334       };
4335     } catch (Dali::DaliException e) {
4336       {
4337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4338       };
4339     } catch (...) {
4340       {
4341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4342       };
4343     }
4344   }
4345
4346   jresult = (void *)result;
4347   return jresult;
4348 }
4349
4350
4351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4352   void * jresult ;
4353   Dali::Vector2 *result = 0 ;
4354
4355   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4356   jresult = (void *)result;
4357   return jresult;
4358 }
4359
4360
4361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4362   void * jresult ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4366   jresult = (void *)result;
4367   return jresult;
4368 }
4369
4370
4371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4372   void * jresult ;
4373   Dali::Vector2 *result = 0 ;
4374
4375   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4376   jresult = (void *)result;
4377   return jresult;
4378 }
4379
4380
4381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4382   void * jresult ;
4383   Dali::Vector2 *result = 0 ;
4384
4385   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4386   jresult = (void *)result;
4387   return jresult;
4388 }
4389
4390
4391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4392   void * jresult ;
4393   Dali::Vector2 *result = 0 ;
4394
4395   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4396   jresult = (void *)result;
4397   return jresult;
4398 }
4399
4400
4401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4402   void * jresult ;
4403   Dali::Vector2 *result = 0 ;
4404
4405   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4406   jresult = (void *)result;
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4412   void * jresult ;
4413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4414   float *arg2 = (float *) 0 ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   arg1 = (Dali::Vector2 *)jarg1;
4418   arg2 = jarg2;
4419   {
4420     try {
4421       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4422     } catch (std::out_of_range& e) {
4423       {
4424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4425       };
4426     } catch (std::exception& e) {
4427       {
4428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4429       };
4430     } catch (Dali::DaliException e) {
4431       {
4432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4433       };
4434     } catch (...) {
4435       {
4436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4437       };
4438     }
4439   }
4440
4441   jresult = (void *)result;
4442
4443
4444   return jresult;
4445 }
4446
4447
4448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4449   void * jresult ;
4450   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4451   Dali::Vector3 *arg2 = 0 ;
4452   Dali::Vector2 *result = 0 ;
4453
4454   arg1 = (Dali::Vector2 *)jarg1;
4455   arg2 = (Dali::Vector3 *)jarg2;
4456   if (!arg2) {
4457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4458     return 0;
4459   }
4460   {
4461     try {
4462       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4463     } catch (std::out_of_range& e) {
4464       {
4465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4466       };
4467     } catch (std::exception& e) {
4468       {
4469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (Dali::DaliException e) {
4472       {
4473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4474       };
4475     } catch (...) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4478       };
4479     }
4480   }
4481
4482   jresult = (void *)result;
4483   return jresult;
4484 }
4485
4486
4487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4488   void * jresult ;
4489   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4490   Dali::Vector4 *arg2 = 0 ;
4491   Dali::Vector2 *result = 0 ;
4492
4493   arg1 = (Dali::Vector2 *)jarg1;
4494   arg2 = (Dali::Vector4 *)jarg2;
4495   if (!arg2) {
4496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4497     return 0;
4498   }
4499   {
4500     try {
4501       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4502     } catch (std::out_of_range& e) {
4503       {
4504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (std::exception& e) {
4507       {
4508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (Dali::DaliException e) {
4511       {
4512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4513       };
4514     } catch (...) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4517       };
4518     }
4519   }
4520
4521   jresult = (void *)result;
4522   return jresult;
4523 }
4524
4525
4526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4527   void * jresult ;
4528   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4529   Dali::Vector2 *arg2 = 0 ;
4530   Dali::Vector2 result;
4531
4532   arg1 = (Dali::Vector2 *)jarg1;
4533   arg2 = (Dali::Vector2 *)jarg2;
4534   if (!arg2) {
4535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4536     return 0;
4537   }
4538   {
4539     try {
4540       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4541     } catch (std::out_of_range& e) {
4542       {
4543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4544       };
4545     } catch (std::exception& e) {
4546       {
4547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4548       };
4549     } catch (Dali::DaliException e) {
4550       {
4551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4552       };
4553     } catch (...) {
4554       {
4555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4556       };
4557     }
4558   }
4559
4560   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4561   return jresult;
4562 }
4563
4564
4565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4566   void * jresult ;
4567   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4568   Dali::Vector2 *arg2 = 0 ;
4569   Dali::Vector2 *result = 0 ;
4570
4571   arg1 = (Dali::Vector2 *)jarg1;
4572   arg2 = (Dali::Vector2 *)jarg2;
4573   if (!arg2) {
4574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4575     return 0;
4576   }
4577   {
4578     try {
4579       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4580     } catch (std::out_of_range& e) {
4581       {
4582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4583       };
4584     } catch (std::exception& e) {
4585       {
4586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4587       };
4588     } catch (Dali::DaliException e) {
4589       {
4590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4591       };
4592     } catch (...) {
4593       {
4594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4595       };
4596     }
4597   }
4598
4599   jresult = (void *)result;
4600   return jresult;
4601 }
4602
4603
4604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4605   void * jresult ;
4606   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4607   Dali::Vector2 *arg2 = 0 ;
4608   Dali::Vector2 result;
4609
4610   arg1 = (Dali::Vector2 *)jarg1;
4611   arg2 = (Dali::Vector2 *)jarg2;
4612   if (!arg2) {
4613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4614     return 0;
4615   }
4616   {
4617     try {
4618       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4619     } catch (std::out_of_range& e) {
4620       {
4621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4622       };
4623     } catch (std::exception& e) {
4624       {
4625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4626       };
4627     } catch (Dali::DaliException e) {
4628       {
4629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4630       };
4631     } catch (...) {
4632       {
4633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4634       };
4635     }
4636   }
4637
4638   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4639   return jresult;
4640 }
4641
4642
4643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4644   void * jresult ;
4645   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4646   Dali::Vector2 *arg2 = 0 ;
4647   Dali::Vector2 *result = 0 ;
4648
4649   arg1 = (Dali::Vector2 *)jarg1;
4650   arg2 = (Dali::Vector2 *)jarg2;
4651   if (!arg2) {
4652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4653     return 0;
4654   }
4655   {
4656     try {
4657       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
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 (Dali::DaliException e) {
4667       {
4668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4669       };
4670     } catch (...) {
4671       {
4672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4673       };
4674     }
4675   }
4676
4677   jresult = (void *)result;
4678   return jresult;
4679 }
4680
4681
4682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4683   void * jresult ;
4684   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4685   Dali::Vector2 *arg2 = 0 ;
4686   Dali::Vector2 result;
4687
4688   arg1 = (Dali::Vector2 *)jarg1;
4689   arg2 = (Dali::Vector2 *)jarg2;
4690   if (!arg2) {
4691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4692     return 0;
4693   }
4694   {
4695     try {
4696       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4697     } catch (std::out_of_range& e) {
4698       {
4699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4700       };
4701     } catch (std::exception& e) {
4702       {
4703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4704       };
4705     } catch (Dali::DaliException e) {
4706       {
4707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4708       };
4709     } catch (...) {
4710       {
4711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4712       };
4713     }
4714   }
4715
4716   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4717   return jresult;
4718 }
4719
4720
4721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4722   void * jresult ;
4723   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4724   float arg2 ;
4725   Dali::Vector2 result;
4726
4727   arg1 = (Dali::Vector2 *)jarg1;
4728   arg2 = (float)jarg2;
4729   {
4730     try {
4731       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4739       };
4740     } catch (Dali::DaliException e) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4743       };
4744     } catch (...) {
4745       {
4746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4747       };
4748     }
4749   }
4750
4751   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4757   void * jresult ;
4758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4759   Dali::Vector2 *arg2 = 0 ;
4760   Dali::Vector2 *result = 0 ;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (Dali::Vector2 *)jarg2;
4764   if (!arg2) {
4765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4766     return 0;
4767   }
4768   {
4769     try {
4770       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4771     } catch (std::out_of_range& e) {
4772       {
4773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4774       };
4775     } catch (std::exception& e) {
4776       {
4777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4778       };
4779     } catch (Dali::DaliException e) {
4780       {
4781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4782       };
4783     } catch (...) {
4784       {
4785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4786       };
4787     }
4788   }
4789
4790   jresult = (void *)result;
4791   return jresult;
4792 }
4793
4794
4795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4796   void * jresult ;
4797   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4798   float arg2 ;
4799   Dali::Vector2 *result = 0 ;
4800
4801   arg1 = (Dali::Vector2 *)jarg1;
4802   arg2 = (float)jarg2;
4803   {
4804     try {
4805       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4806     } catch (std::out_of_range& e) {
4807       {
4808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4809       };
4810     } catch (std::exception& e) {
4811       {
4812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4813       };
4814     } catch (Dali::DaliException e) {
4815       {
4816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4817       };
4818     } catch (...) {
4819       {
4820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4821       };
4822     }
4823   }
4824
4825   jresult = (void *)result;
4826   return jresult;
4827 }
4828
4829
4830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4831   void * jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   Dali::Vector2 *arg2 = 0 ;
4834   Dali::Vector2 result;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   arg2 = (Dali::Vector2 *)jarg2;
4838   if (!arg2) {
4839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4840     return 0;
4841   }
4842   {
4843     try {
4844       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4845     } catch (std::out_of_range& e) {
4846       {
4847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4848       };
4849     } catch (std::exception& e) {
4850       {
4851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4852       };
4853     } catch (Dali::DaliException e) {
4854       {
4855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4856       };
4857     } catch (...) {
4858       {
4859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4860       };
4861     }
4862   }
4863
4864   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4865   return jresult;
4866 }
4867
4868
4869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4870   void * jresult ;
4871   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4872   float arg2 ;
4873   Dali::Vector2 result;
4874
4875   arg1 = (Dali::Vector2 *)jarg1;
4876   arg2 = (float)jarg2;
4877   {
4878     try {
4879       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4880     } catch (std::out_of_range& e) {
4881       {
4882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4883       };
4884     } catch (std::exception& e) {
4885       {
4886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4887       };
4888     } catch (Dali::DaliException e) {
4889       {
4890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4891       };
4892     } catch (...) {
4893       {
4894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4895       };
4896     }
4897   }
4898
4899   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4900   return jresult;
4901 }
4902
4903
4904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4905   void * jresult ;
4906   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4907   Dali::Vector2 *arg2 = 0 ;
4908   Dali::Vector2 *result = 0 ;
4909
4910   arg1 = (Dali::Vector2 *)jarg1;
4911   arg2 = (Dali::Vector2 *)jarg2;
4912   if (!arg2) {
4913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4914     return 0;
4915   }
4916   {
4917     try {
4918       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4919     } catch (std::out_of_range& e) {
4920       {
4921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4922       };
4923     } catch (std::exception& e) {
4924       {
4925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4926       };
4927     } catch (Dali::DaliException e) {
4928       {
4929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4930       };
4931     } catch (...) {
4932       {
4933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4934       };
4935     }
4936   }
4937
4938   jresult = (void *)result;
4939   return jresult;
4940 }
4941
4942
4943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4944   void * jresult ;
4945   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4946   float arg2 ;
4947   Dali::Vector2 *result = 0 ;
4948
4949   arg1 = (Dali::Vector2 *)jarg1;
4950   arg2 = (float)jarg2;
4951   {
4952     try {
4953       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4961       };
4962     } catch (Dali::DaliException e) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4965       };
4966     } catch (...) {
4967       {
4968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4969       };
4970     }
4971   }
4972
4973   jresult = (void *)result;
4974   return jresult;
4975 }
4976
4977
4978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4979   void * jresult ;
4980   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4981   Dali::Vector2 result;
4982
4983   arg1 = (Dali::Vector2 *)jarg1;
4984   {
4985     try {
4986       result = ((Dali::Vector2 const *)arg1)->operator -();
4987     } catch (std::out_of_range& e) {
4988       {
4989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4990       };
4991     } catch (std::exception& e) {
4992       {
4993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4994       };
4995     } catch (Dali::DaliException e) {
4996       {
4997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4998       };
4999     } catch (...) {
5000       {
5001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5002       };
5003     }
5004   }
5005
5006   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5007   return jresult;
5008 }
5009
5010
5011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5012   unsigned int jresult ;
5013   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5014   Dali::Vector2 *arg2 = 0 ;
5015   bool result;
5016
5017   arg1 = (Dali::Vector2 *)jarg1;
5018   arg2 = (Dali::Vector2 *)jarg2;
5019   if (!arg2) {
5020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5021     return 0;
5022   }
5023   {
5024     try {
5025       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5026     } catch (std::out_of_range& e) {
5027       {
5028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (std::exception& e) {
5031       {
5032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (Dali::DaliException e) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5037       };
5038     } catch (...) {
5039       {
5040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5041       };
5042     }
5043   }
5044
5045   jresult = result;
5046   return jresult;
5047 }
5048
5049
5050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5051   unsigned int jresult ;
5052   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5053   Dali::Vector2 *arg2 = 0 ;
5054   bool result;
5055
5056   arg1 = (Dali::Vector2 *)jarg1;
5057   arg2 = (Dali::Vector2 *)jarg2;
5058   if (!arg2) {
5059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5060     return 0;
5061   }
5062   {
5063     try {
5064       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5065     } catch (std::out_of_range& e) {
5066       {
5067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5068       };
5069     } catch (std::exception& e) {
5070       {
5071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5072       };
5073     } catch (Dali::DaliException e) {
5074       {
5075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5076       };
5077     } catch (...) {
5078       {
5079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5080       };
5081     }
5082   }
5083
5084   jresult = result;
5085   return jresult;
5086 }
5087
5088
5089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5090   float jresult ;
5091   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5092   unsigned int arg2 ;
5093   float *result = 0 ;
5094
5095   arg1 = (Dali::Vector2 *)jarg1;
5096   arg2 = (unsigned int)jarg2;
5097   {
5098     try {
5099       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5100     } catch (std::out_of_range& e) {
5101       {
5102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5103       };
5104     } catch (std::exception& e) {
5105       {
5106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5107       };
5108     } catch (Dali::DaliException e) {
5109       {
5110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5111       };
5112     } catch (...) {
5113       {
5114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5115       };
5116     }
5117   }
5118
5119   jresult = *result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5125   float jresult ;
5126   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5127   float result;
5128
5129   arg1 = (Dali::Vector2 *)jarg1;
5130   {
5131     try {
5132       result = (float)((Dali::Vector2 const *)arg1)->Length();
5133     } catch (std::out_of_range& e) {
5134       {
5135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5136       };
5137     } catch (std::exception& e) {
5138       {
5139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5140       };
5141     } catch (Dali::DaliException e) {
5142       {
5143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5144       };
5145     } catch (...) {
5146       {
5147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5148       };
5149     }
5150   }
5151
5152   jresult = result;
5153   return jresult;
5154 }
5155
5156
5157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5158   float jresult ;
5159   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5160   float result;
5161
5162   arg1 = (Dali::Vector2 *)jarg1;
5163   {
5164     try {
5165       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5166     } catch (std::out_of_range& e) {
5167       {
5168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5169       };
5170     } catch (std::exception& e) {
5171       {
5172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5173       };
5174     } catch (Dali::DaliException e) {
5175       {
5176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5177       };
5178     } catch (...) {
5179       {
5180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5181       };
5182     }
5183   }
5184
5185   jresult = result;
5186   return jresult;
5187 }
5188
5189
5190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5191   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5192
5193   arg1 = (Dali::Vector2 *)jarg1;
5194   {
5195     try {
5196       (arg1)->Normalize();
5197     } catch (std::out_of_range& e) {
5198       {
5199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5200       };
5201     } catch (std::exception& e) {
5202       {
5203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5204       };
5205     } catch (Dali::DaliException e) {
5206       {
5207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5208       };
5209     } catch (...) {
5210       {
5211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5212       };
5213     }
5214   }
5215
5216 }
5217
5218
5219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5220   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5221   Dali::Vector2 *arg2 = 0 ;
5222   Dali::Vector2 *arg3 = 0 ;
5223
5224   arg1 = (Dali::Vector2 *)jarg1;
5225   arg2 = (Dali::Vector2 *)jarg2;
5226   if (!arg2) {
5227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5228     return ;
5229   }
5230   arg3 = (Dali::Vector2 *)jarg3;
5231   if (!arg3) {
5232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5233     return ;
5234   }
5235   {
5236     try {
5237       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5238     } catch (std::out_of_range& e) {
5239       {
5240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5241       };
5242     } catch (std::exception& e) {
5243       {
5244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5245       };
5246     } catch (Dali::DaliException e) {
5247       {
5248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5249       };
5250     } catch (...) {
5251       {
5252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5253       };
5254     }
5255   }
5256
5257 }
5258
5259
5260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5261   void * jresult ;
5262   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5263   float *result = 0 ;
5264
5265   arg1 = (Dali::Vector2 *)jarg1;
5266   {
5267     try {
5268       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5269     } catch (std::out_of_range& e) {
5270       {
5271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5272       };
5273     } catch (std::exception& e) {
5274       {
5275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5276       };
5277     } catch (Dali::DaliException e) {
5278       {
5279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5280       };
5281     } catch (...) {
5282       {
5283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5284       };
5285     }
5286   }
5287
5288   jresult = (void *)result;
5289   return jresult;
5290 }
5291
5292
5293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5294   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5295   float arg2 ;
5296
5297   arg1 = (Dali::Vector2 *)jarg1;
5298   arg2 = (float)jarg2;
5299   if (arg1) (arg1)->x = arg2;
5300 }
5301
5302
5303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5304   float jresult ;
5305   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5306   float result;
5307
5308   arg1 = (Dali::Vector2 *)jarg1;
5309   result = (float) ((arg1)->x);
5310   jresult = result;
5311   return jresult;
5312 }
5313
5314
5315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5316   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5317   float arg2 ;
5318
5319   arg1 = (Dali::Vector2 *)jarg1;
5320   arg2 = (float)jarg2;
5321   if (arg1) (arg1)->width = arg2;
5322 }
5323
5324
5325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5326   float jresult ;
5327   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5328   float result;
5329
5330   arg1 = (Dali::Vector2 *)jarg1;
5331   result = (float) ((arg1)->width);
5332   jresult = result;
5333   return jresult;
5334 }
5335
5336
5337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5338   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5339   float arg2 ;
5340
5341   arg1 = (Dali::Vector2 *)jarg1;
5342   arg2 = (float)jarg2;
5343   if (arg1) (arg1)->y = arg2;
5344 }
5345
5346
5347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5348   float jresult ;
5349   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5350   float result;
5351
5352   arg1 = (Dali::Vector2 *)jarg1;
5353   result = (float) ((arg1)->y);
5354   jresult = result;
5355   return jresult;
5356 }
5357
5358
5359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5360   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5361   float arg2 ;
5362
5363   arg1 = (Dali::Vector2 *)jarg1;
5364   arg2 = (float)jarg2;
5365   if (arg1) (arg1)->height = arg2;
5366 }
5367
5368
5369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5370   float jresult ;
5371   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5372   float result;
5373
5374   arg1 = (Dali::Vector2 *)jarg1;
5375   result = (float) ((arg1)->height);
5376   jresult = result;
5377   return jresult;
5378 }
5379
5380
5381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5383
5384   arg1 = (Dali::Vector2 *)jarg1;
5385   {
5386     try {
5387       delete arg1;
5388     } catch (std::out_of_range& e) {
5389       {
5390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5391       };
5392     } catch (std::exception& e) {
5393       {
5394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5395       };
5396     } catch (Dali::DaliException e) {
5397       {
5398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5399       };
5400     } catch (...) {
5401       {
5402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5403       };
5404     }
5405   }
5406
5407 }
5408
5409
5410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5411   void * jresult ;
5412   Dali::Vector2 *arg1 = 0 ;
5413   Dali::Vector2 *arg2 = 0 ;
5414   Dali::Vector2 result;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   if (!arg1) {
5418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5419     return 0;
5420   }
5421   arg2 = (Dali::Vector2 *)jarg2;
5422   if (!arg2) {
5423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5424     return 0;
5425   }
5426   {
5427     try {
5428       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5429     } catch (std::out_of_range& e) {
5430       {
5431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5432       };
5433     } catch (std::exception& e) {
5434       {
5435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5436       };
5437     } catch (Dali::DaliException e) {
5438       {
5439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5440       };
5441     } catch (...) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5444       };
5445     }
5446   }
5447
5448   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector2 *arg1 = 0 ;
5456   Dali::Vector2 *arg2 = 0 ;
5457   Dali::Vector2 result;
5458
5459   arg1 = (Dali::Vector2 *)jarg1;
5460   if (!arg1) {
5461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5462     return 0;
5463   }
5464   arg2 = (Dali::Vector2 *)jarg2;
5465   if (!arg2) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   {
5470     try {
5471       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5472     } catch (std::out_of_range& e) {
5473       {
5474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (std::exception& e) {
5477       {
5478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5479       };
5480     } catch (Dali::DaliException e) {
5481       {
5482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5483       };
5484     } catch (...) {
5485       {
5486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5487       };
5488     }
5489   }
5490
5491   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5492   return jresult;
5493 }
5494
5495
5496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5497   void * jresult ;
5498   Dali::Vector2 *arg1 = 0 ;
5499   float *arg2 = 0 ;
5500   float *arg3 = 0 ;
5501   float temp2 ;
5502   float temp3 ;
5503   Dali::Vector2 result;
5504
5505   arg1 = (Dali::Vector2 *)jarg1;
5506   if (!arg1) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5508     return 0;
5509   }
5510   temp2 = (float)jarg2;
5511   arg2 = &temp2;
5512   temp3 = (float)jarg3;
5513   arg3 = &temp3;
5514   {
5515     try {
5516       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (Dali::DaliException e) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5528       };
5529     } catch (...) {
5530       {
5531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5532       };
5533     }
5534   }
5535
5536   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5537   return jresult;
5538 }
5539
5540
5541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5542   void * jresult ;
5543   Dali::Vector3 *result = 0 ;
5544
5545   {
5546     try {
5547       result = (Dali::Vector3 *)new Dali::Vector3();
5548     } catch (std::out_of_range& e) {
5549       {
5550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5551       };
5552     } catch (std::exception& e) {
5553       {
5554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5555       };
5556     } catch (Dali::DaliException e) {
5557       {
5558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5559       };
5560     } catch (...) {
5561       {
5562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5563       };
5564     }
5565   }
5566
5567   jresult = (void *)result;
5568   return jresult;
5569 }
5570
5571
5572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5573   void * jresult ;
5574   float arg1 ;
5575   float arg2 ;
5576   float arg3 ;
5577   Dali::Vector3 *result = 0 ;
5578
5579   arg1 = (float)jarg1;
5580   arg2 = (float)jarg2;
5581   arg3 = (float)jarg3;
5582   {
5583     try {
5584       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5585     } catch (std::out_of_range& e) {
5586       {
5587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5588       };
5589     } catch (std::exception& e) {
5590       {
5591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5592       };
5593     } catch (Dali::DaliException e) {
5594       {
5595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5596       };
5597     } catch (...) {
5598       {
5599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5600       };
5601     }
5602   }
5603
5604   jresult = (void *)result;
5605   return jresult;
5606 }
5607
5608
5609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5610   void * jresult ;
5611   float *arg1 = (float *) 0 ;
5612   Dali::Vector3 *result = 0 ;
5613
5614   arg1 = jarg1;
5615   {
5616     try {
5617       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5618     } catch (std::out_of_range& e) {
5619       {
5620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5621       };
5622     } catch (std::exception& e) {
5623       {
5624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5625       };
5626     } catch (Dali::DaliException e) {
5627       {
5628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5629       };
5630     } catch (...) {
5631       {
5632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5633       };
5634     }
5635   }
5636
5637   jresult = (void *)result;
5638
5639
5640   return jresult;
5641 }
5642
5643
5644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5645   void * jresult ;
5646   Dali::Vector2 *arg1 = 0 ;
5647   Dali::Vector3 *result = 0 ;
5648
5649   arg1 = (Dali::Vector2 *)jarg1;
5650   if (!arg1) {
5651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5652     return 0;
5653   }
5654   {
5655     try {
5656       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5657     } catch (std::out_of_range& e) {
5658       {
5659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5660       };
5661     } catch (std::exception& e) {
5662       {
5663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5664       };
5665     } catch (Dali::DaliException e) {
5666       {
5667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5668       };
5669     } catch (...) {
5670       {
5671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5672       };
5673     }
5674   }
5675
5676   jresult = (void *)result;
5677   return jresult;
5678 }
5679
5680
5681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5682   void * jresult ;
5683   Dali::Vector4 *arg1 = 0 ;
5684   Dali::Vector3 *result = 0 ;
5685
5686   arg1 = (Dali::Vector4 *)jarg1;
5687   if (!arg1) {
5688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5689     return 0;
5690   }
5691   {
5692     try {
5693       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5694     } catch (std::out_of_range& e) {
5695       {
5696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5697       };
5698     } catch (std::exception& e) {
5699       {
5700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (Dali::DaliException e) {
5703       {
5704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5705       };
5706     } catch (...) {
5707       {
5708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5709       };
5710     }
5711   }
5712
5713   jresult = (void *)result;
5714   return jresult;
5715 }
5716
5717
5718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5719   void * jresult ;
5720   Dali::Vector3 *result = 0 ;
5721
5722   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5723   jresult = (void *)result;
5724   return jresult;
5725 }
5726
5727
5728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5729   void * jresult ;
5730   Dali::Vector3 *result = 0 ;
5731
5732   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5733   jresult = (void *)result;
5734   return jresult;
5735 }
5736
5737
5738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5739   void * jresult ;
5740   Dali::Vector3 *result = 0 ;
5741
5742   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5743   jresult = (void *)result;
5744   return jresult;
5745 }
5746
5747
5748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5749   void * jresult ;
5750   Dali::Vector3 *result = 0 ;
5751
5752   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5753   jresult = (void *)result;
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5759   void * jresult ;
5760   Dali::Vector3 *result = 0 ;
5761
5762   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5763   jresult = (void *)result;
5764   return jresult;
5765 }
5766
5767
5768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5769   void * jresult ;
5770   Dali::Vector3 *result = 0 ;
5771
5772   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5773   jresult = (void *)result;
5774   return jresult;
5775 }
5776
5777
5778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5779   void * jresult ;
5780   Dali::Vector3 *result = 0 ;
5781
5782   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5783   jresult = (void *)result;
5784   return jresult;
5785 }
5786
5787
5788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5789   void * jresult ;
5790   Dali::Vector3 *result = 0 ;
5791
5792   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5793   jresult = (void *)result;
5794   return jresult;
5795 }
5796
5797
5798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5799   void * jresult ;
5800   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5801   float *arg2 = (float *) 0 ;
5802   Dali::Vector3 *result = 0 ;
5803
5804   arg1 = (Dali::Vector3 *)jarg1;
5805   arg2 = jarg2;
5806   {
5807     try {
5808       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5809     } catch (std::out_of_range& e) {
5810       {
5811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5812       };
5813     } catch (std::exception& e) {
5814       {
5815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5816       };
5817     } catch (Dali::DaliException e) {
5818       {
5819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5820       };
5821     } catch (...) {
5822       {
5823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5824       };
5825     }
5826   }
5827
5828   jresult = (void *)result;
5829
5830
5831   return jresult;
5832 }
5833
5834
5835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5836   void * jresult ;
5837   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5838   Dali::Vector2 *arg2 = 0 ;
5839   Dali::Vector3 *result = 0 ;
5840
5841   arg1 = (Dali::Vector3 *)jarg1;
5842   arg2 = (Dali::Vector2 *)jarg2;
5843   if (!arg2) {
5844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5845     return 0;
5846   }
5847   {
5848     try {
5849       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5850     } catch (std::out_of_range& e) {
5851       {
5852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5853       };
5854     } catch (std::exception& e) {
5855       {
5856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (Dali::DaliException e) {
5859       {
5860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5861       };
5862     } catch (...) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5865       };
5866     }
5867   }
5868
5869   jresult = (void *)result;
5870   return jresult;
5871 }
5872
5873
5874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5875   void * jresult ;
5876   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5877   Dali::Vector4 *arg2 = 0 ;
5878   Dali::Vector3 *result = 0 ;
5879
5880   arg1 = (Dali::Vector3 *)jarg1;
5881   arg2 = (Dali::Vector4 *)jarg2;
5882   if (!arg2) {
5883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5884     return 0;
5885   }
5886   {
5887     try {
5888       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5889     } catch (std::out_of_range& e) {
5890       {
5891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5892       };
5893     } catch (std::exception& e) {
5894       {
5895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5896       };
5897     } catch (Dali::DaliException e) {
5898       {
5899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5900       };
5901     } catch (...) {
5902       {
5903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5904       };
5905     }
5906   }
5907
5908   jresult = (void *)result;
5909   return jresult;
5910 }
5911
5912
5913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5914   void * jresult ;
5915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5916   Dali::Vector3 *arg2 = 0 ;
5917   Dali::Vector3 result;
5918
5919   arg1 = (Dali::Vector3 *)jarg1;
5920   arg2 = (Dali::Vector3 *)jarg2;
5921   if (!arg2) {
5922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5923     return 0;
5924   }
5925   {
5926     try {
5927       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5928     } catch (std::out_of_range& e) {
5929       {
5930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5931       };
5932     } catch (std::exception& e) {
5933       {
5934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (Dali::DaliException e) {
5937       {
5938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5939       };
5940     } catch (...) {
5941       {
5942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5943       };
5944     }
5945   }
5946
5947   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5948   return jresult;
5949 }
5950
5951
5952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5953   void * jresult ;
5954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5955   Dali::Vector3 *arg2 = 0 ;
5956   Dali::Vector3 *result = 0 ;
5957
5958   arg1 = (Dali::Vector3 *)jarg1;
5959   arg2 = (Dali::Vector3 *)jarg2;
5960   if (!arg2) {
5961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5962     return 0;
5963   }
5964   {
5965     try {
5966       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5967     } catch (std::out_of_range& e) {
5968       {
5969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5970       };
5971     } catch (std::exception& e) {
5972       {
5973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5974       };
5975     } catch (Dali::DaliException e) {
5976       {
5977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5978       };
5979     } catch (...) {
5980       {
5981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5982       };
5983     }
5984   }
5985
5986   jresult = (void *)result;
5987   return jresult;
5988 }
5989
5990
5991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5992   void * jresult ;
5993   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5994   Dali::Vector3 *arg2 = 0 ;
5995   Dali::Vector3 result;
5996
5997   arg1 = (Dali::Vector3 *)jarg1;
5998   arg2 = (Dali::Vector3 *)jarg2;
5999   if (!arg2) {
6000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6001     return 0;
6002   }
6003   {
6004     try {
6005       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6006     } catch (std::out_of_range& e) {
6007       {
6008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6009       };
6010     } catch (std::exception& e) {
6011       {
6012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (Dali::DaliException e) {
6015       {
6016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6017       };
6018     } catch (...) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6021       };
6022     }
6023   }
6024
6025   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6026   return jresult;
6027 }
6028
6029
6030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6031   void * jresult ;
6032   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6033   Dali::Vector3 *arg2 = 0 ;
6034   Dali::Vector3 *result = 0 ;
6035
6036   arg1 = (Dali::Vector3 *)jarg1;
6037   arg2 = (Dali::Vector3 *)jarg2;
6038   if (!arg2) {
6039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6040     return 0;
6041   }
6042   {
6043     try {
6044       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6045     } catch (std::out_of_range& e) {
6046       {
6047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6048       };
6049     } catch (std::exception& e) {
6050       {
6051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (Dali::DaliException e) {
6054       {
6055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6056       };
6057     } catch (...) {
6058       {
6059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6060       };
6061     }
6062   }
6063
6064   jresult = (void *)result;
6065   return jresult;
6066 }
6067
6068
6069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6070   void * jresult ;
6071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6072   Dali::Vector3 *arg2 = 0 ;
6073   Dali::Vector3 result;
6074
6075   arg1 = (Dali::Vector3 *)jarg1;
6076   arg2 = (Dali::Vector3 *)jarg2;
6077   if (!arg2) {
6078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6079     return 0;
6080   }
6081   {
6082     try {
6083       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6084     } catch (std::out_of_range& e) {
6085       {
6086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6087       };
6088     } catch (std::exception& e) {
6089       {
6090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6091       };
6092     } catch (Dali::DaliException e) {
6093       {
6094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6095       };
6096     } catch (...) {
6097       {
6098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6099       };
6100     }
6101   }
6102
6103   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6104   return jresult;
6105 }
6106
6107
6108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6109   void * jresult ;
6110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6111   float arg2 ;
6112   Dali::Vector3 result;
6113
6114   arg1 = (Dali::Vector3 *)jarg1;
6115   arg2 = (float)jarg2;
6116   {
6117     try {
6118       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6119     } catch (std::out_of_range& e) {
6120       {
6121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6122       };
6123     } catch (std::exception& e) {
6124       {
6125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6126       };
6127     } catch (Dali::DaliException e) {
6128       {
6129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6130       };
6131     } catch (...) {
6132       {
6133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6134       };
6135     }
6136   }
6137
6138   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6139   return jresult;
6140 }
6141
6142
6143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6144   void * jresult ;
6145   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6146   Dali::Vector3 *arg2 = 0 ;
6147   Dali::Vector3 *result = 0 ;
6148
6149   arg1 = (Dali::Vector3 *)jarg1;
6150   arg2 = (Dali::Vector3 *)jarg2;
6151   if (!arg2) {
6152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6153     return 0;
6154   }
6155   {
6156     try {
6157       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6158     } catch (std::out_of_range& e) {
6159       {
6160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6161       };
6162     } catch (std::exception& e) {
6163       {
6164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6165       };
6166     } catch (Dali::DaliException e) {
6167       {
6168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6169       };
6170     } catch (...) {
6171       {
6172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6173       };
6174     }
6175   }
6176
6177   jresult = (void *)result;
6178   return jresult;
6179 }
6180
6181
6182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6183   void * jresult ;
6184   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6185   float arg2 ;
6186   Dali::Vector3 *result = 0 ;
6187
6188   arg1 = (Dali::Vector3 *)jarg1;
6189   arg2 = (float)jarg2;
6190   {
6191     try {
6192       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6193     } catch (std::out_of_range& e) {
6194       {
6195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6196       };
6197     } catch (std::exception& e) {
6198       {
6199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6200       };
6201     } catch (Dali::DaliException e) {
6202       {
6203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6204       };
6205     } catch (...) {
6206       {
6207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6208       };
6209     }
6210   }
6211
6212   jresult = (void *)result;
6213   return jresult;
6214 }
6215
6216
6217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6218   void * jresult ;
6219   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6220   Dali::Quaternion *arg2 = 0 ;
6221   Dali::Vector3 *result = 0 ;
6222
6223   arg1 = (Dali::Vector3 *)jarg1;
6224   arg2 = (Dali::Quaternion *)jarg2;
6225   if (!arg2) {
6226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6227     return 0;
6228   }
6229   {
6230     try {
6231       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6232     } catch (std::out_of_range& e) {
6233       {
6234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6235       };
6236     } catch (std::exception& e) {
6237       {
6238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6239       };
6240     } catch (Dali::DaliException e) {
6241       {
6242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6243       };
6244     } catch (...) {
6245       {
6246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6247       };
6248     }
6249   }
6250
6251   jresult = (void *)result;
6252   return jresult;
6253 }
6254
6255
6256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6257   void * jresult ;
6258   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6259   Dali::Vector3 *arg2 = 0 ;
6260   Dali::Vector3 result;
6261
6262   arg1 = (Dali::Vector3 *)jarg1;
6263   arg2 = (Dali::Vector3 *)jarg2;
6264   if (!arg2) {
6265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6266     return 0;
6267   }
6268   {
6269     try {
6270       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6271     } catch (std::out_of_range& e) {
6272       {
6273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6274       };
6275     } catch (std::exception& e) {
6276       {
6277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6278       };
6279     } catch (Dali::DaliException e) {
6280       {
6281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6282       };
6283     } catch (...) {
6284       {
6285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6286       };
6287     }
6288   }
6289
6290   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6291   return jresult;
6292 }
6293
6294
6295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6296   void * jresult ;
6297   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6298   float arg2 ;
6299   Dali::Vector3 result;
6300
6301   arg1 = (Dali::Vector3 *)jarg1;
6302   arg2 = (float)jarg2;
6303   {
6304     try {
6305       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6306     } catch (std::out_of_range& e) {
6307       {
6308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6309       };
6310     } catch (std::exception& e) {
6311       {
6312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6313       };
6314     } catch (Dali::DaliException e) {
6315       {
6316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6317       };
6318     } catch (...) {
6319       {
6320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6321       };
6322     }
6323   }
6324
6325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6326   return jresult;
6327 }
6328
6329
6330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6331   void * jresult ;
6332   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6333   Dali::Vector3 *arg2 = 0 ;
6334   Dali::Vector3 *result = 0 ;
6335
6336   arg1 = (Dali::Vector3 *)jarg1;
6337   arg2 = (Dali::Vector3 *)jarg2;
6338   if (!arg2) {
6339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6340     return 0;
6341   }
6342   {
6343     try {
6344       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6345     } catch (std::out_of_range& e) {
6346       {
6347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6348       };
6349     } catch (std::exception& e) {
6350       {
6351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6352       };
6353     } catch (Dali::DaliException e) {
6354       {
6355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6356       };
6357     } catch (...) {
6358       {
6359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6360       };
6361     }
6362   }
6363
6364   jresult = (void *)result;
6365   return jresult;
6366 }
6367
6368
6369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6370   void * jresult ;
6371   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6372   float arg2 ;
6373   Dali::Vector3 *result = 0 ;
6374
6375   arg1 = (Dali::Vector3 *)jarg1;
6376   arg2 = (float)jarg2;
6377   {
6378     try {
6379       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6380     } catch (std::out_of_range& e) {
6381       {
6382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (std::exception& e) {
6385       {
6386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6387       };
6388     } catch (Dali::DaliException e) {
6389       {
6390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6391       };
6392     } catch (...) {
6393       {
6394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6395       };
6396     }
6397   }
6398
6399   jresult = (void *)result;
6400   return jresult;
6401 }
6402
6403
6404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6405   void * jresult ;
6406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6407   Dali::Vector3 result;
6408
6409   arg1 = (Dali::Vector3 *)jarg1;
6410   {
6411     try {
6412       result = ((Dali::Vector3 const *)arg1)->operator -();
6413     } catch (std::out_of_range& e) {
6414       {
6415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6416       };
6417     } catch (std::exception& e) {
6418       {
6419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6420       };
6421     } catch (Dali::DaliException e) {
6422       {
6423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6424       };
6425     } catch (...) {
6426       {
6427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6428       };
6429     }
6430   }
6431
6432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6438   unsigned int jresult ;
6439   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6440   Dali::Vector3 *arg2 = 0 ;
6441   bool result;
6442
6443   arg1 = (Dali::Vector3 *)jarg1;
6444   arg2 = (Dali::Vector3 *)jarg2;
6445   if (!arg2) {
6446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6447     return 0;
6448   }
6449   {
6450     try {
6451       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6452     } catch (std::out_of_range& e) {
6453       {
6454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6455       };
6456     } catch (std::exception& e) {
6457       {
6458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6459       };
6460     } catch (Dali::DaliException e) {
6461       {
6462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6463       };
6464     } catch (...) {
6465       {
6466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6467       };
6468     }
6469   }
6470
6471   jresult = result;
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6477   unsigned int jresult ;
6478   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6479   Dali::Vector3 *arg2 = 0 ;
6480   bool result;
6481
6482   arg1 = (Dali::Vector3 *)jarg1;
6483   arg2 = (Dali::Vector3 *)jarg2;
6484   if (!arg2) {
6485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6486     return 0;
6487   }
6488   {
6489     try {
6490       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6491     } catch (std::out_of_range& e) {
6492       {
6493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6494       };
6495     } catch (std::exception& e) {
6496       {
6497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6498       };
6499     } catch (Dali::DaliException e) {
6500       {
6501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6502       };
6503     } catch (...) {
6504       {
6505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6506       };
6507     }
6508   }
6509
6510   jresult = result;
6511   return jresult;
6512 }
6513
6514
6515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6516   float jresult ;
6517   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6518   unsigned int arg2 ;
6519   float *result = 0 ;
6520
6521   arg1 = (Dali::Vector3 *)jarg1;
6522   arg2 = (unsigned int)jarg2;
6523   {
6524     try {
6525       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6526     } catch (std::out_of_range& e) {
6527       {
6528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6529       };
6530     } catch (std::exception& e) {
6531       {
6532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6533       };
6534     } catch (Dali::DaliException e) {
6535       {
6536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6537       };
6538     } catch (...) {
6539       {
6540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6541       };
6542     }
6543   }
6544
6545   jresult = *result;
6546   return jresult;
6547 }
6548
6549
6550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6551   float jresult ;
6552   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6553   Dali::Vector3 *arg2 = 0 ;
6554   float result;
6555
6556   arg1 = (Dali::Vector3 *)jarg1;
6557   arg2 = (Dali::Vector3 *)jarg2;
6558   if (!arg2) {
6559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6560     return 0;
6561   }
6562   {
6563     try {
6564       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6565     } catch (std::out_of_range& e) {
6566       {
6567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (std::exception& e) {
6570       {
6571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6572       };
6573     } catch (Dali::DaliException e) {
6574       {
6575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6576       };
6577     } catch (...) {
6578       {
6579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6580       };
6581     }
6582   }
6583
6584   jresult = result;
6585   return jresult;
6586 }
6587
6588
6589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6590   void * jresult ;
6591   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6592   Dali::Vector3 *arg2 = 0 ;
6593   Dali::Vector3 result;
6594
6595   arg1 = (Dali::Vector3 *)jarg1;
6596   arg2 = (Dali::Vector3 *)jarg2;
6597   if (!arg2) {
6598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6599     return 0;
6600   }
6601   {
6602     try {
6603       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6604     } catch (std::out_of_range& e) {
6605       {
6606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6607       };
6608     } catch (std::exception& e) {
6609       {
6610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6611       };
6612     } catch (Dali::DaliException e) {
6613       {
6614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6615       };
6616     } catch (...) {
6617       {
6618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6619       };
6620     }
6621   }
6622
6623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6624   return jresult;
6625 }
6626
6627
6628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6629   float jresult ;
6630   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6631   float result;
6632
6633   arg1 = (Dali::Vector3 *)jarg1;
6634   {
6635     try {
6636       result = (float)((Dali::Vector3 const *)arg1)->Length();
6637     } catch (std::out_of_range& e) {
6638       {
6639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6640       };
6641     } catch (std::exception& e) {
6642       {
6643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6644       };
6645     } catch (Dali::DaliException e) {
6646       {
6647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6648       };
6649     } catch (...) {
6650       {
6651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6652       };
6653     }
6654   }
6655
6656   jresult = result;
6657   return jresult;
6658 }
6659
6660
6661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6662   float jresult ;
6663   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6664   float result;
6665
6666   arg1 = (Dali::Vector3 *)jarg1;
6667   {
6668     try {
6669       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6670     } catch (std::out_of_range& e) {
6671       {
6672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6673       };
6674     } catch (std::exception& e) {
6675       {
6676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6677       };
6678     } catch (Dali::DaliException e) {
6679       {
6680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6681       };
6682     } catch (...) {
6683       {
6684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6685       };
6686     }
6687   }
6688
6689   jresult = result;
6690   return jresult;
6691 }
6692
6693
6694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6695   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6696
6697   arg1 = (Dali::Vector3 *)jarg1;
6698   {
6699     try {
6700       (arg1)->Normalize();
6701     } catch (std::out_of_range& e) {
6702       {
6703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6704       };
6705     } catch (std::exception& e) {
6706       {
6707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6708       };
6709     } catch (Dali::DaliException e) {
6710       {
6711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6712       };
6713     } catch (...) {
6714       {
6715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6716       };
6717     }
6718   }
6719
6720 }
6721
6722
6723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6724   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6725   Dali::Vector3 *arg2 = 0 ;
6726   Dali::Vector3 *arg3 = 0 ;
6727
6728   arg1 = (Dali::Vector3 *)jarg1;
6729   arg2 = (Dali::Vector3 *)jarg2;
6730   if (!arg2) {
6731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6732     return ;
6733   }
6734   arg3 = (Dali::Vector3 *)jarg3;
6735   if (!arg3) {
6736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6737     return ;
6738   }
6739   {
6740     try {
6741       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6742     } catch (std::out_of_range& e) {
6743       {
6744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6745       };
6746     } catch (std::exception& e) {
6747       {
6748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6749       };
6750     } catch (Dali::DaliException e) {
6751       {
6752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6753       };
6754     } catch (...) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6757       };
6758     }
6759   }
6760
6761 }
6762
6763
6764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6765   void * jresult ;
6766   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6767   float *result = 0 ;
6768
6769   arg1 = (Dali::Vector3 *)jarg1;
6770   {
6771     try {
6772       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6773     } catch (std::out_of_range& e) {
6774       {
6775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6776       };
6777     } catch (std::exception& e) {
6778       {
6779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6780       };
6781     } catch (Dali::DaliException e) {
6782       {
6783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6784       };
6785     } catch (...) {
6786       {
6787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6788       };
6789     }
6790   }
6791
6792   jresult = (void *)result;
6793   return jresult;
6794 }
6795
6796
6797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6798   void * jresult ;
6799   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6800   Dali::Vector2 *result = 0 ;
6801
6802   arg1 = (Dali::Vector3 *)jarg1;
6803   {
6804     try {
6805       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6806     } catch (std::out_of_range& e) {
6807       {
6808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6809       };
6810     } catch (std::exception& e) {
6811       {
6812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6813       };
6814     } catch (Dali::DaliException e) {
6815       {
6816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6817       };
6818     } catch (...) {
6819       {
6820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6821       };
6822     }
6823   }
6824
6825   jresult = (void *)result;
6826   return jresult;
6827 }
6828
6829
6830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6831   void * jresult ;
6832   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6833   Dali::Vector2 *result = 0 ;
6834
6835   arg1 = (Dali::Vector3 *)jarg1;
6836   {
6837     try {
6838       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6839     } catch (std::out_of_range& e) {
6840       {
6841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6842       };
6843     } catch (std::exception& e) {
6844       {
6845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6846       };
6847     } catch (Dali::DaliException e) {
6848       {
6849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6850       };
6851     } catch (...) {
6852       {
6853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6854       };
6855     }
6856   }
6857
6858   jresult = (void *)result;
6859   return jresult;
6860 }
6861
6862
6863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6864   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6865   float arg2 ;
6866
6867   arg1 = (Dali::Vector3 *)jarg1;
6868   arg2 = (float)jarg2;
6869   if (arg1) (arg1)->x = arg2;
6870 }
6871
6872
6873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6874   float jresult ;
6875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6876   float result;
6877
6878   arg1 = (Dali::Vector3 *)jarg1;
6879   result = (float) ((arg1)->x);
6880   jresult = result;
6881   return jresult;
6882 }
6883
6884
6885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6886   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6887   float arg2 ;
6888
6889   arg1 = (Dali::Vector3 *)jarg1;
6890   arg2 = (float)jarg2;
6891   if (arg1) (arg1)->width = arg2;
6892 }
6893
6894
6895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6896   float jresult ;
6897   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6898   float result;
6899
6900   arg1 = (Dali::Vector3 *)jarg1;
6901   result = (float) ((arg1)->width);
6902   jresult = result;
6903   return jresult;
6904 }
6905
6906
6907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6908   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6909   float arg2 ;
6910
6911   arg1 = (Dali::Vector3 *)jarg1;
6912   arg2 = (float)jarg2;
6913   if (arg1) (arg1)->r = arg2;
6914 }
6915
6916
6917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6918   float jresult ;
6919   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6920   float result;
6921
6922   arg1 = (Dali::Vector3 *)jarg1;
6923   result = (float) ((arg1)->r);
6924   jresult = result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6930   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6931   float arg2 ;
6932
6933   arg1 = (Dali::Vector3 *)jarg1;
6934   arg2 = (float)jarg2;
6935   if (arg1) (arg1)->y = arg2;
6936 }
6937
6938
6939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6940   float jresult ;
6941   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6942   float result;
6943
6944   arg1 = (Dali::Vector3 *)jarg1;
6945   result = (float) ((arg1)->y);
6946   jresult = result;
6947   return jresult;
6948 }
6949
6950
6951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6952   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6953   float arg2 ;
6954
6955   arg1 = (Dali::Vector3 *)jarg1;
6956   arg2 = (float)jarg2;
6957   if (arg1) (arg1)->height = arg2;
6958 }
6959
6960
6961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6962   float jresult ;
6963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6964   float result;
6965
6966   arg1 = (Dali::Vector3 *)jarg1;
6967   result = (float) ((arg1)->height);
6968   jresult = result;
6969   return jresult;
6970 }
6971
6972
6973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6974   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6975   float arg2 ;
6976
6977   arg1 = (Dali::Vector3 *)jarg1;
6978   arg2 = (float)jarg2;
6979   if (arg1) (arg1)->g = arg2;
6980 }
6981
6982
6983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6984   float jresult ;
6985   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6986   float result;
6987
6988   arg1 = (Dali::Vector3 *)jarg1;
6989   result = (float) ((arg1)->g);
6990   jresult = result;
6991   return jresult;
6992 }
6993
6994
6995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6997   float arg2 ;
6998
6999   arg1 = (Dali::Vector3 *)jarg1;
7000   arg2 = (float)jarg2;
7001   if (arg1) (arg1)->z = arg2;
7002 }
7003
7004
7005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7006   float jresult ;
7007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7008   float result;
7009
7010   arg1 = (Dali::Vector3 *)jarg1;
7011   result = (float) ((arg1)->z);
7012   jresult = result;
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7019   float arg2 ;
7020
7021   arg1 = (Dali::Vector3 *)jarg1;
7022   arg2 = (float)jarg2;
7023   if (arg1) (arg1)->depth = arg2;
7024 }
7025
7026
7027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7028   float jresult ;
7029   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7030   float result;
7031
7032   arg1 = (Dali::Vector3 *)jarg1;
7033   result = (float) ((arg1)->depth);
7034   jresult = result;
7035   return jresult;
7036 }
7037
7038
7039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7040   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7041   float arg2 ;
7042
7043   arg1 = (Dali::Vector3 *)jarg1;
7044   arg2 = (float)jarg2;
7045   if (arg1) (arg1)->b = arg2;
7046 }
7047
7048
7049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7050   float jresult ;
7051   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7052   float result;
7053
7054   arg1 = (Dali::Vector3 *)jarg1;
7055   result = (float) ((arg1)->b);
7056   jresult = result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7062   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7063
7064   arg1 = (Dali::Vector3 *)jarg1;
7065   {
7066     try {
7067       delete arg1;
7068     } catch (std::out_of_range& e) {
7069       {
7070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7071       };
7072     } catch (std::exception& e) {
7073       {
7074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7075       };
7076     } catch (Dali::DaliException e) {
7077       {
7078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7079       };
7080     } catch (...) {
7081       {
7082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7083       };
7084     }
7085   }
7086
7087 }
7088
7089
7090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7091   void * jresult ;
7092   Dali::Vector3 *arg1 = 0 ;
7093   Dali::Vector3 *arg2 = 0 ;
7094   Dali::Vector3 result;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   if (!arg1) {
7098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7099     return 0;
7100   }
7101   arg2 = (Dali::Vector3 *)jarg2;
7102   if (!arg2) {
7103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7104     return 0;
7105   }
7106   {
7107     try {
7108       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7109     } catch (std::out_of_range& e) {
7110       {
7111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7112       };
7113     } catch (std::exception& e) {
7114       {
7115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7116       };
7117     } catch (Dali::DaliException e) {
7118       {
7119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7120       };
7121     } catch (...) {
7122       {
7123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7124       };
7125     }
7126   }
7127
7128   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7129   return jresult;
7130 }
7131
7132
7133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7134   void * jresult ;
7135   Dali::Vector3 *arg1 = 0 ;
7136   Dali::Vector3 *arg2 = 0 ;
7137   Dali::Vector3 result;
7138
7139   arg1 = (Dali::Vector3 *)jarg1;
7140   if (!arg1) {
7141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7142     return 0;
7143   }
7144   arg2 = (Dali::Vector3 *)jarg2;
7145   if (!arg2) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   {
7150     try {
7151       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7152     } catch (std::out_of_range& e) {
7153       {
7154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7155       };
7156     } catch (std::exception& e) {
7157       {
7158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (Dali::DaliException e) {
7161       {
7162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7163       };
7164     } catch (...) {
7165       {
7166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7167       };
7168     }
7169   }
7170
7171   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7172   return jresult;
7173 }
7174
7175
7176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7177   void * jresult ;
7178   Dali::Vector3 *arg1 = 0 ;
7179   float *arg2 = 0 ;
7180   float *arg3 = 0 ;
7181   float temp2 ;
7182   float temp3 ;
7183   Dali::Vector3 result;
7184
7185   arg1 = (Dali::Vector3 *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7188     return 0;
7189   }
7190   temp2 = (float)jarg2;
7191   arg2 = &temp2;
7192   temp3 = (float)jarg3;
7193   arg3 = &temp3;
7194   {
7195     try {
7196       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7197     } catch (std::out_of_range& e) {
7198       {
7199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7200       };
7201     } catch (std::exception& e) {
7202       {
7203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (Dali::DaliException e) {
7206       {
7207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215
7216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7222   void * jresult ;
7223   Dali::Vector4 *result = 0 ;
7224
7225   {
7226     try {
7227       result = (Dali::Vector4 *)new Dali::Vector4();
7228     } catch (std::out_of_range& e) {
7229       {
7230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7231       };
7232     } catch (std::exception& e) {
7233       {
7234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7235       };
7236     } catch (Dali::DaliException e) {
7237       {
7238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7239       };
7240     } catch (...) {
7241       {
7242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7243       };
7244     }
7245   }
7246
7247   jresult = (void *)result;
7248   return jresult;
7249 }
7250
7251
7252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7253   void * jresult ;
7254   float arg1 ;
7255   float arg2 ;
7256   float arg3 ;
7257   float arg4 ;
7258   Dali::Vector4 *result = 0 ;
7259
7260   arg1 = (float)jarg1;
7261   arg2 = (float)jarg2;
7262   arg3 = (float)jarg3;
7263   arg4 = (float)jarg4;
7264   {
7265     try {
7266       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7267     } catch (std::out_of_range& e) {
7268       {
7269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (std::exception& e) {
7272       {
7273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (Dali::DaliException e) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7278       };
7279     } catch (...) {
7280       {
7281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7282       };
7283     }
7284   }
7285
7286   jresult = (void *)result;
7287   return jresult;
7288 }
7289
7290
7291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7292   void * jresult ;
7293   float *arg1 = (float *) 0 ;
7294   Dali::Vector4 *result = 0 ;
7295
7296   arg1 = jarg1;
7297   {
7298     try {
7299       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
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 (Dali::DaliException e) {
7309       {
7310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7311       };
7312     } catch (...) {
7313       {
7314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7315       };
7316     }
7317   }
7318
7319   jresult = (void *)result;
7320
7321
7322   return jresult;
7323 }
7324
7325
7326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7327   void * jresult ;
7328   Dali::Vector2 *arg1 = 0 ;
7329   Dali::Vector4 *result = 0 ;
7330
7331   arg1 = (Dali::Vector2 *)jarg1;
7332   if (!arg1) {
7333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7334     return 0;
7335   }
7336   {
7337     try {
7338       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7339     } catch (std::out_of_range& e) {
7340       {
7341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7342       };
7343     } catch (std::exception& e) {
7344       {
7345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7346       };
7347     } catch (Dali::DaliException e) {
7348       {
7349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7350       };
7351     } catch (...) {
7352       {
7353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7354       };
7355     }
7356   }
7357
7358   jresult = (void *)result;
7359   return jresult;
7360 }
7361
7362
7363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7364   void * jresult ;
7365   Dali::Vector3 *arg1 = 0 ;
7366   Dali::Vector4 *result = 0 ;
7367
7368   arg1 = (Dali::Vector3 *)jarg1;
7369   if (!arg1) {
7370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7371     return 0;
7372   }
7373   {
7374     try {
7375       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7376     } catch (std::out_of_range& e) {
7377       {
7378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7379       };
7380     } catch (std::exception& e) {
7381       {
7382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (Dali::DaliException e) {
7385       {
7386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394
7395   jresult = (void *)result;
7396   return jresult;
7397 }
7398
7399
7400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7401   void * jresult ;
7402   Dali::Vector4 *result = 0 ;
7403
7404   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7405   jresult = (void *)result;
7406   return jresult;
7407 }
7408
7409
7410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7411   void * jresult ;
7412   Dali::Vector4 *result = 0 ;
7413
7414   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7415   jresult = (void *)result;
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7421   void * jresult ;
7422   Dali::Vector4 *result = 0 ;
7423
7424   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7425   jresult = (void *)result;
7426   return jresult;
7427 }
7428
7429
7430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7431   void * jresult ;
7432   Dali::Vector4 *result = 0 ;
7433
7434   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7435   jresult = (void *)result;
7436   return jresult;
7437 }
7438
7439
7440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7441   void * jresult ;
7442   Dali::Vector4 *result = 0 ;
7443
7444   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7445   jresult = (void *)result;
7446   return jresult;
7447 }
7448
7449
7450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7451   void * jresult ;
7452   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7453   float *arg2 = (float *) 0 ;
7454   Dali::Vector4 *result = 0 ;
7455
7456   arg1 = (Dali::Vector4 *)jarg1;
7457   arg2 = jarg2;
7458   {
7459     try {
7460       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7461     } catch (std::out_of_range& e) {
7462       {
7463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7464       };
7465     } catch (std::exception& e) {
7466       {
7467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7468       };
7469     } catch (Dali::DaliException e) {
7470       {
7471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7472       };
7473     } catch (...) {
7474       {
7475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7476       };
7477     }
7478   }
7479
7480   jresult = (void *)result;
7481
7482
7483   return jresult;
7484 }
7485
7486
7487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7488   void * jresult ;
7489   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7490   Dali::Vector2 *arg2 = 0 ;
7491   Dali::Vector4 *result = 0 ;
7492
7493   arg1 = (Dali::Vector4 *)jarg1;
7494   arg2 = (Dali::Vector2 *)jarg2;
7495   if (!arg2) {
7496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7497     return 0;
7498   }
7499   {
7500     try {
7501       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7502     } catch (std::out_of_range& e) {
7503       {
7504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7505       };
7506     } catch (std::exception& e) {
7507       {
7508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (Dali::DaliException e) {
7511       {
7512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7513       };
7514     } catch (...) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7517       };
7518     }
7519   }
7520
7521   jresult = (void *)result;
7522   return jresult;
7523 }
7524
7525
7526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7527   void * jresult ;
7528   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7529   Dali::Vector3 *arg2 = 0 ;
7530   Dali::Vector4 *result = 0 ;
7531
7532   arg1 = (Dali::Vector4 *)jarg1;
7533   arg2 = (Dali::Vector3 *)jarg2;
7534   if (!arg2) {
7535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7536     return 0;
7537   }
7538   {
7539     try {
7540       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7541     } catch (std::out_of_range& e) {
7542       {
7543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7544       };
7545     } catch (std::exception& e) {
7546       {
7547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (Dali::DaliException e) {
7550       {
7551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7552       };
7553     } catch (...) {
7554       {
7555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7556       };
7557     }
7558   }
7559
7560   jresult = (void *)result;
7561   return jresult;
7562 }
7563
7564
7565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7566   void * jresult ;
7567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7568   Dali::Vector4 *arg2 = 0 ;
7569   Dali::Vector4 result;
7570
7571   arg1 = (Dali::Vector4 *)jarg1;
7572   arg2 = (Dali::Vector4 *)jarg2;
7573   if (!arg2) {
7574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7575     return 0;
7576   }
7577   {
7578     try {
7579       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7580     } catch (std::out_of_range& e) {
7581       {
7582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7583       };
7584     } catch (std::exception& e) {
7585       {
7586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7587       };
7588     } catch (Dali::DaliException e) {
7589       {
7590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7591       };
7592     } catch (...) {
7593       {
7594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7595       };
7596     }
7597   }
7598
7599   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7600   return jresult;
7601 }
7602
7603
7604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7605   void * jresult ;
7606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7607   Dali::Vector4 *arg2 = 0 ;
7608   Dali::Vector4 *result = 0 ;
7609
7610   arg1 = (Dali::Vector4 *)jarg1;
7611   arg2 = (Dali::Vector4 *)jarg2;
7612   if (!arg2) {
7613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7614     return 0;
7615   }
7616   {
7617     try {
7618       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7619     } catch (std::out_of_range& e) {
7620       {
7621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7622       };
7623     } catch (std::exception& e) {
7624       {
7625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7626       };
7627     } catch (Dali::DaliException e) {
7628       {
7629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7630       };
7631     } catch (...) {
7632       {
7633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7634       };
7635     }
7636   }
7637
7638   jresult = (void *)result;
7639   return jresult;
7640 }
7641
7642
7643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7644   void * jresult ;
7645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7646   Dali::Vector4 *arg2 = 0 ;
7647   Dali::Vector4 result;
7648
7649   arg1 = (Dali::Vector4 *)jarg1;
7650   arg2 = (Dali::Vector4 *)jarg2;
7651   if (!arg2) {
7652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7653     return 0;
7654   }
7655   {
7656     try {
7657       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7658     } catch (std::out_of_range& e) {
7659       {
7660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7661       };
7662     } catch (std::exception& e) {
7663       {
7664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7665       };
7666     } catch (Dali::DaliException e) {
7667       {
7668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7669       };
7670     } catch (...) {
7671       {
7672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7673       };
7674     }
7675   }
7676
7677   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7678   return jresult;
7679 }
7680
7681
7682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7683   void * jresult ;
7684   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7685   Dali::Vector4 *arg2 = 0 ;
7686   Dali::Vector4 *result = 0 ;
7687
7688   arg1 = (Dali::Vector4 *)jarg1;
7689   arg2 = (Dali::Vector4 *)jarg2;
7690   if (!arg2) {
7691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7692     return 0;
7693   }
7694   {
7695     try {
7696       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7697     } catch (std::out_of_range& e) {
7698       {
7699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7700       };
7701     } catch (std::exception& e) {
7702       {
7703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7704       };
7705     } catch (Dali::DaliException e) {
7706       {
7707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7708       };
7709     } catch (...) {
7710       {
7711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7712       };
7713     }
7714   }
7715
7716   jresult = (void *)result;
7717   return jresult;
7718 }
7719
7720
7721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7722   void * jresult ;
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   Dali::Vector4 *arg2 = 0 ;
7725   Dali::Vector4 result;
7726
7727   arg1 = (Dali::Vector4 *)jarg1;
7728   arg2 = (Dali::Vector4 *)jarg2;
7729   if (!arg2) {
7730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7731     return 0;
7732   }
7733   {
7734     try {
7735       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7736     } catch (std::out_of_range& e) {
7737       {
7738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7739       };
7740     } catch (std::exception& e) {
7741       {
7742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7743       };
7744     } catch (Dali::DaliException e) {
7745       {
7746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7747       };
7748     } catch (...) {
7749       {
7750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7751       };
7752     }
7753   }
7754
7755   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7756   return jresult;
7757 }
7758
7759
7760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7761   void * jresult ;
7762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7763   float arg2 ;
7764   Dali::Vector4 result;
7765
7766   arg1 = (Dali::Vector4 *)jarg1;
7767   arg2 = (float)jarg2;
7768   {
7769     try {
7770       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7771     } catch (std::out_of_range& e) {
7772       {
7773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7774       };
7775     } catch (std::exception& e) {
7776       {
7777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7778       };
7779     } catch (Dali::DaliException e) {
7780       {
7781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7782       };
7783     } catch (...) {
7784       {
7785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7786       };
7787     }
7788   }
7789
7790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7791   return jresult;
7792 }
7793
7794
7795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7796   void * jresult ;
7797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7798   Dali::Vector4 *arg2 = 0 ;
7799   Dali::Vector4 *result = 0 ;
7800
7801   arg1 = (Dali::Vector4 *)jarg1;
7802   arg2 = (Dali::Vector4 *)jarg2;
7803   if (!arg2) {
7804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7805     return 0;
7806   }
7807   {
7808     try {
7809       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7810     } catch (std::out_of_range& e) {
7811       {
7812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7813       };
7814     } catch (std::exception& e) {
7815       {
7816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7817       };
7818     } catch (Dali::DaliException e) {
7819       {
7820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7821       };
7822     } catch (...) {
7823       {
7824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7825       };
7826     }
7827   }
7828
7829   jresult = (void *)result;
7830   return jresult;
7831 }
7832
7833
7834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7835   void * jresult ;
7836   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7837   float arg2 ;
7838   Dali::Vector4 *result = 0 ;
7839
7840   arg1 = (Dali::Vector4 *)jarg1;
7841   arg2 = (float)jarg2;
7842   {
7843     try {
7844       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7845     } catch (std::out_of_range& e) {
7846       {
7847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7848       };
7849     } catch (std::exception& e) {
7850       {
7851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7852       };
7853     } catch (Dali::DaliException e) {
7854       {
7855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7856       };
7857     } catch (...) {
7858       {
7859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7860       };
7861     }
7862   }
7863
7864   jresult = (void *)result;
7865   return jresult;
7866 }
7867
7868
7869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7870   void * jresult ;
7871   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7872   Dali::Vector4 *arg2 = 0 ;
7873   Dali::Vector4 result;
7874
7875   arg1 = (Dali::Vector4 *)jarg1;
7876   arg2 = (Dali::Vector4 *)jarg2;
7877   if (!arg2) {
7878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7879     return 0;
7880   }
7881   {
7882     try {
7883       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7884     } catch (std::out_of_range& e) {
7885       {
7886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7887       };
7888     } catch (std::exception& e) {
7889       {
7890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7891       };
7892     } catch (Dali::DaliException e) {
7893       {
7894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7895       };
7896     } catch (...) {
7897       {
7898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7899       };
7900     }
7901   }
7902
7903   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7904   return jresult;
7905 }
7906
7907
7908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7909   void * jresult ;
7910   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7911   float arg2 ;
7912   Dali::Vector4 result;
7913
7914   arg1 = (Dali::Vector4 *)jarg1;
7915   arg2 = (float)jarg2;
7916   {
7917     try {
7918       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7919     } catch (std::out_of_range& e) {
7920       {
7921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7922       };
7923     } catch (std::exception& e) {
7924       {
7925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7926       };
7927     } catch (Dali::DaliException e) {
7928       {
7929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7930       };
7931     } catch (...) {
7932       {
7933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7934       };
7935     }
7936   }
7937
7938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7946   Dali::Vector4 *arg2 = 0 ;
7947   Dali::Vector4 *result = 0 ;
7948
7949   arg1 = (Dali::Vector4 *)jarg1;
7950   arg2 = (Dali::Vector4 *)jarg2;
7951   if (!arg2) {
7952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7953     return 0;
7954   }
7955   {
7956     try {
7957       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7958     } catch (std::out_of_range& e) {
7959       {
7960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7961       };
7962     } catch (std::exception& e) {
7963       {
7964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7965       };
7966     } catch (Dali::DaliException e) {
7967       {
7968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7969       };
7970     } catch (...) {
7971       {
7972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7973       };
7974     }
7975   }
7976
7977   jresult = (void *)result;
7978   return jresult;
7979 }
7980
7981
7982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7983   void * jresult ;
7984   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7985   float arg2 ;
7986   Dali::Vector4 *result = 0 ;
7987
7988   arg1 = (Dali::Vector4 *)jarg1;
7989   arg2 = (float)jarg2;
7990   {
7991     try {
7992       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7993     } catch (std::out_of_range& e) {
7994       {
7995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7996       };
7997     } catch (std::exception& e) {
7998       {
7999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8000       };
8001     } catch (Dali::DaliException e) {
8002       {
8003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8004       };
8005     } catch (...) {
8006       {
8007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8008       };
8009     }
8010   }
8011
8012   jresult = (void *)result;
8013   return jresult;
8014 }
8015
8016
8017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8018   void * jresult ;
8019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8020   Dali::Vector4 result;
8021
8022   arg1 = (Dali::Vector4 *)jarg1;
8023   {
8024     try {
8025       result = ((Dali::Vector4 const *)arg1)->operator -();
8026     } catch (std::out_of_range& e) {
8027       {
8028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8029       };
8030     } catch (std::exception& e) {
8031       {
8032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8033       };
8034     } catch (Dali::DaliException e) {
8035       {
8036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8037       };
8038     } catch (...) {
8039       {
8040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8041       };
8042     }
8043   }
8044
8045   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8046   return jresult;
8047 }
8048
8049
8050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8051   unsigned int jresult ;
8052   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8053   Dali::Vector4 *arg2 = 0 ;
8054   bool result;
8055
8056   arg1 = (Dali::Vector4 *)jarg1;
8057   arg2 = (Dali::Vector4 *)jarg2;
8058   if (!arg2) {
8059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8060     return 0;
8061   }
8062   {
8063     try {
8064       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8065     } catch (std::out_of_range& e) {
8066       {
8067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8068       };
8069     } catch (std::exception& e) {
8070       {
8071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8072       };
8073     } catch (Dali::DaliException e) {
8074       {
8075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8076       };
8077     } catch (...) {
8078       {
8079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8080       };
8081     }
8082   }
8083
8084   jresult = result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8090   unsigned int jresult ;
8091   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8092   Dali::Vector4 *arg2 = 0 ;
8093   bool result;
8094
8095   arg1 = (Dali::Vector4 *)jarg1;
8096   arg2 = (Dali::Vector4 *)jarg2;
8097   if (!arg2) {
8098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8099     return 0;
8100   }
8101   {
8102     try {
8103       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8104     } catch (std::out_of_range& e) {
8105       {
8106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (std::exception& e) {
8109       {
8110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8111       };
8112     } catch (Dali::DaliException e) {
8113       {
8114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8115       };
8116     } catch (...) {
8117       {
8118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8119       };
8120     }
8121   }
8122
8123   jresult = result;
8124   return jresult;
8125 }
8126
8127
8128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8129   float jresult ;
8130   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8131   unsigned int arg2 ;
8132   float *result = 0 ;
8133
8134   arg1 = (Dali::Vector4 *)jarg1;
8135   arg2 = (unsigned int)jarg2;
8136   {
8137     try {
8138       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8139     } catch (std::out_of_range& e) {
8140       {
8141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8142       };
8143     } catch (std::exception& e) {
8144       {
8145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8146       };
8147     } catch (Dali::DaliException e) {
8148       {
8149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8150       };
8151     } catch (...) {
8152       {
8153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8154       };
8155     }
8156   }
8157
8158   jresult = *result;
8159   return jresult;
8160 }
8161
8162
8163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8164   float jresult ;
8165   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8166   Dali::Vector3 *arg2 = 0 ;
8167   float result;
8168
8169   arg1 = (Dali::Vector4 *)jarg1;
8170   arg2 = (Dali::Vector3 *)jarg2;
8171   if (!arg2) {
8172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8173     return 0;
8174   }
8175   {
8176     try {
8177       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8178     } catch (std::out_of_range& e) {
8179       {
8180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8181       };
8182     } catch (std::exception& e) {
8183       {
8184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8185       };
8186     } catch (Dali::DaliException e) {
8187       {
8188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8189       };
8190     } catch (...) {
8191       {
8192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8193       };
8194     }
8195   }
8196
8197   jresult = result;
8198   return jresult;
8199 }
8200
8201
8202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8203   float jresult ;
8204   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8205   Dali::Vector4 *arg2 = 0 ;
8206   float result;
8207
8208   arg1 = (Dali::Vector4 *)jarg1;
8209   arg2 = (Dali::Vector4 *)jarg2;
8210   if (!arg2) {
8211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8212     return 0;
8213   }
8214   {
8215     try {
8216       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8217     } catch (std::out_of_range& e) {
8218       {
8219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8220       };
8221     } catch (std::exception& e) {
8222       {
8223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8224       };
8225     } catch (Dali::DaliException e) {
8226       {
8227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8228       };
8229     } catch (...) {
8230       {
8231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8232       };
8233     }
8234   }
8235
8236   jresult = result;
8237   return jresult;
8238 }
8239
8240
8241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8242   float jresult ;
8243   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8244   Dali::Vector4 *arg2 = 0 ;
8245   float result;
8246
8247   arg1 = (Dali::Vector4 *)jarg1;
8248   arg2 = (Dali::Vector4 *)jarg2;
8249   if (!arg2) {
8250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8251     return 0;
8252   }
8253   {
8254     try {
8255       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8256     } catch (std::out_of_range& e) {
8257       {
8258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8259       };
8260     } catch (std::exception& e) {
8261       {
8262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (Dali::DaliException e) {
8265       {
8266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8267       };
8268     } catch (...) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8271       };
8272     }
8273   }
8274
8275   jresult = result;
8276   return jresult;
8277 }
8278
8279
8280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8281   void * jresult ;
8282   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8283   Dali::Vector4 *arg2 = 0 ;
8284   Dali::Vector4 result;
8285
8286   arg1 = (Dali::Vector4 *)jarg1;
8287   arg2 = (Dali::Vector4 *)jarg2;
8288   if (!arg2) {
8289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8290     return 0;
8291   }
8292   {
8293     try {
8294       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8295     } catch (std::out_of_range& e) {
8296       {
8297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8298       };
8299     } catch (std::exception& e) {
8300       {
8301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8302       };
8303     } catch (Dali::DaliException e) {
8304       {
8305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8306       };
8307     } catch (...) {
8308       {
8309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8310       };
8311     }
8312   }
8313
8314   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8315   return jresult;
8316 }
8317
8318
8319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8320   float jresult ;
8321   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8322   float result;
8323
8324   arg1 = (Dali::Vector4 *)jarg1;
8325   {
8326     try {
8327       result = (float)((Dali::Vector4 const *)arg1)->Length();
8328     } catch (std::out_of_range& e) {
8329       {
8330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8331       };
8332     } catch (std::exception& e) {
8333       {
8334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8335       };
8336     } catch (Dali::DaliException e) {
8337       {
8338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8339       };
8340     } catch (...) {
8341       {
8342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8343       };
8344     }
8345   }
8346
8347   jresult = result;
8348   return jresult;
8349 }
8350
8351
8352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8353   float jresult ;
8354   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8355   float result;
8356
8357   arg1 = (Dali::Vector4 *)jarg1;
8358   {
8359     try {
8360       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8361     } catch (std::out_of_range& e) {
8362       {
8363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8364       };
8365     } catch (std::exception& e) {
8366       {
8367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8368       };
8369     } catch (Dali::DaliException e) {
8370       {
8371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8372       };
8373     } catch (...) {
8374       {
8375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8376       };
8377     }
8378   }
8379
8380   jresult = result;
8381   return jresult;
8382 }
8383
8384
8385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8386   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8387
8388   arg1 = (Dali::Vector4 *)jarg1;
8389   {
8390     try {
8391       (arg1)->Normalize();
8392     } catch (std::out_of_range& e) {
8393       {
8394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8395       };
8396     } catch (std::exception& e) {
8397       {
8398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8399       };
8400     } catch (Dali::DaliException e) {
8401       {
8402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8403       };
8404     } catch (...) {
8405       {
8406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8407       };
8408     }
8409   }
8410
8411 }
8412
8413
8414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8415   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8416   Dali::Vector4 *arg2 = 0 ;
8417   Dali::Vector4 *arg3 = 0 ;
8418
8419   arg1 = (Dali::Vector4 *)jarg1;
8420   arg2 = (Dali::Vector4 *)jarg2;
8421   if (!arg2) {
8422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8423     return ;
8424   }
8425   arg3 = (Dali::Vector4 *)jarg3;
8426   if (!arg3) {
8427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8428     return ;
8429   }
8430   {
8431     try {
8432       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8433     } catch (std::out_of_range& e) {
8434       {
8435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8436       };
8437     } catch (std::exception& e) {
8438       {
8439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8440       };
8441     } catch (Dali::DaliException e) {
8442       {
8443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8444       };
8445     } catch (...) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8448       };
8449     }
8450   }
8451
8452 }
8453
8454
8455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8456   void * jresult ;
8457   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8458   float *result = 0 ;
8459
8460   arg1 = (Dali::Vector4 *)jarg1;
8461   {
8462     try {
8463       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8464     } catch (std::out_of_range& e) {
8465       {
8466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8467       };
8468     } catch (std::exception& e) {
8469       {
8470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8471       };
8472     } catch (Dali::DaliException e) {
8473       {
8474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8475       };
8476     } catch (...) {
8477       {
8478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8479       };
8480     }
8481   }
8482
8483   jresult = (void *)result;
8484   return jresult;
8485 }
8486
8487
8488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8489   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8490   float arg2 ;
8491
8492   arg1 = (Dali::Vector4 *)jarg1;
8493   arg2 = (float)jarg2;
8494   if (arg1) (arg1)->x = arg2;
8495 }
8496
8497
8498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8499   float jresult ;
8500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8501   float result;
8502
8503   arg1 = (Dali::Vector4 *)jarg1;
8504   result = (float) ((arg1)->x);
8505   jresult = result;
8506   return jresult;
8507 }
8508
8509
8510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8511   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8512   float arg2 ;
8513
8514   arg1 = (Dali::Vector4 *)jarg1;
8515   arg2 = (float)jarg2;
8516   if (arg1) (arg1)->r = arg2;
8517 }
8518
8519
8520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8521   float jresult ;
8522   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8523   float result;
8524
8525   arg1 = (Dali::Vector4 *)jarg1;
8526   result = (float) ((arg1)->r);
8527   jresult = result;
8528   return jresult;
8529 }
8530
8531
8532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8533   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8534   float arg2 ;
8535
8536   arg1 = (Dali::Vector4 *)jarg1;
8537   arg2 = (float)jarg2;
8538   if (arg1) (arg1)->s = arg2;
8539 }
8540
8541
8542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8543   float jresult ;
8544   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8545   float result;
8546
8547   arg1 = (Dali::Vector4 *)jarg1;
8548   result = (float) ((arg1)->s);
8549   jresult = result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8555   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8556   float arg2 ;
8557
8558   arg1 = (Dali::Vector4 *)jarg1;
8559   arg2 = (float)jarg2;
8560   if (arg1) (arg1)->y = arg2;
8561 }
8562
8563
8564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8565   float jresult ;
8566   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8567   float result;
8568
8569   arg1 = (Dali::Vector4 *)jarg1;
8570   result = (float) ((arg1)->y);
8571   jresult = result;
8572   return jresult;
8573 }
8574
8575
8576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8577   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8578   float arg2 ;
8579
8580   arg1 = (Dali::Vector4 *)jarg1;
8581   arg2 = (float)jarg2;
8582   if (arg1) (arg1)->g = arg2;
8583 }
8584
8585
8586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8587   float jresult ;
8588   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8589   float result;
8590
8591   arg1 = (Dali::Vector4 *)jarg1;
8592   result = (float) ((arg1)->g);
8593   jresult = result;
8594   return jresult;
8595 }
8596
8597
8598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8599   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8600   float arg2 ;
8601
8602   arg1 = (Dali::Vector4 *)jarg1;
8603   arg2 = (float)jarg2;
8604   if (arg1) (arg1)->t = arg2;
8605 }
8606
8607
8608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8609   float jresult ;
8610   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8611   float result;
8612
8613   arg1 = (Dali::Vector4 *)jarg1;
8614   result = (float) ((arg1)->t);
8615   jresult = result;
8616   return jresult;
8617 }
8618
8619
8620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8622   float arg2 ;
8623
8624   arg1 = (Dali::Vector4 *)jarg1;
8625   arg2 = (float)jarg2;
8626   if (arg1) (arg1)->z = arg2;
8627 }
8628
8629
8630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8631   float jresult ;
8632   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8633   float result;
8634
8635   arg1 = (Dali::Vector4 *)jarg1;
8636   result = (float) ((arg1)->z);
8637   jresult = result;
8638   return jresult;
8639 }
8640
8641
8642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8643   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8644   float arg2 ;
8645
8646   arg1 = (Dali::Vector4 *)jarg1;
8647   arg2 = (float)jarg2;
8648   if (arg1) (arg1)->b = arg2;
8649 }
8650
8651
8652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8653   float jresult ;
8654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8655   float result;
8656
8657   arg1 = (Dali::Vector4 *)jarg1;
8658   result = (float) ((arg1)->b);
8659   jresult = result;
8660   return jresult;
8661 }
8662
8663
8664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8665   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8666   float arg2 ;
8667
8668   arg1 = (Dali::Vector4 *)jarg1;
8669   arg2 = (float)jarg2;
8670   if (arg1) (arg1)->p = arg2;
8671 }
8672
8673
8674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8675   float jresult ;
8676   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8677   float result;
8678
8679   arg1 = (Dali::Vector4 *)jarg1;
8680   result = (float) ((arg1)->p);
8681   jresult = result;
8682   return jresult;
8683 }
8684
8685
8686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8687   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8688   float arg2 ;
8689
8690   arg1 = (Dali::Vector4 *)jarg1;
8691   arg2 = (float)jarg2;
8692   if (arg1) (arg1)->w = arg2;
8693 }
8694
8695
8696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8697   float jresult ;
8698   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8699   float result;
8700
8701   arg1 = (Dali::Vector4 *)jarg1;
8702   result = (float) ((arg1)->w);
8703   jresult = result;
8704   return jresult;
8705 }
8706
8707
8708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8709   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8710   float arg2 ;
8711
8712   arg1 = (Dali::Vector4 *)jarg1;
8713   arg2 = (float)jarg2;
8714   if (arg1) (arg1)->a = arg2;
8715 }
8716
8717
8718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8719   float jresult ;
8720   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8721   float result;
8722
8723   arg1 = (Dali::Vector4 *)jarg1;
8724   result = (float) ((arg1)->a);
8725   jresult = result;
8726   return jresult;
8727 }
8728
8729
8730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8731   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8732   float arg2 ;
8733
8734   arg1 = (Dali::Vector4 *)jarg1;
8735   arg2 = (float)jarg2;
8736   if (arg1) (arg1)->q = arg2;
8737 }
8738
8739
8740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8741   float jresult ;
8742   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8743   float result;
8744
8745   arg1 = (Dali::Vector4 *)jarg1;
8746   result = (float) ((arg1)->q);
8747   jresult = result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8753   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8754
8755   arg1 = (Dali::Vector4 *)jarg1;
8756   {
8757     try {
8758       delete arg1;
8759     } catch (std::out_of_range& e) {
8760       {
8761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8762       };
8763     } catch (std::exception& e) {
8764       {
8765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8766       };
8767     } catch (Dali::DaliException e) {
8768       {
8769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8770       };
8771     } catch (...) {
8772       {
8773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8774       };
8775     }
8776   }
8777
8778 }
8779
8780
8781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8782   void * jresult ;
8783   Dali::Vector4 *arg1 = 0 ;
8784   Dali::Vector4 *arg2 = 0 ;
8785   Dali::Vector4 result;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   if (!arg1) {
8789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8790     return 0;
8791   }
8792   arg2 = (Dali::Vector4 *)jarg2;
8793   if (!arg2) {
8794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8795     return 0;
8796   }
8797   {
8798     try {
8799       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8800     } catch (std::out_of_range& e) {
8801       {
8802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8803       };
8804     } catch (std::exception& e) {
8805       {
8806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8807       };
8808     } catch (Dali::DaliException e) {
8809       {
8810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8811       };
8812     } catch (...) {
8813       {
8814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8815       };
8816     }
8817   }
8818
8819   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8820   return jresult;
8821 }
8822
8823
8824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8825   void * jresult ;
8826   Dali::Vector4 *arg1 = 0 ;
8827   Dali::Vector4 *arg2 = 0 ;
8828   Dali::Vector4 result;
8829
8830   arg1 = (Dali::Vector4 *)jarg1;
8831   if (!arg1) {
8832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8833     return 0;
8834   }
8835   arg2 = (Dali::Vector4 *)jarg2;
8836   if (!arg2) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   {
8841     try {
8842       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8843     } catch (std::out_of_range& e) {
8844       {
8845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8846       };
8847     } catch (std::exception& e) {
8848       {
8849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (Dali::DaliException e) {
8852       {
8853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8854       };
8855     } catch (...) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8858       };
8859     }
8860   }
8861
8862   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8863   return jresult;
8864 }
8865
8866
8867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8868   void * jresult ;
8869   Dali::Vector4 *arg1 = 0 ;
8870   float *arg2 = 0 ;
8871   float *arg3 = 0 ;
8872   float temp2 ;
8873   float temp3 ;
8874   Dali::Vector4 result;
8875
8876   arg1 = (Dali::Vector4 *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8879     return 0;
8880   }
8881   temp2 = (float)jarg2;
8882   arg2 = &temp2;
8883   temp3 = (float)jarg3;
8884   arg3 = &temp3;
8885   {
8886     try {
8887       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8888     } catch (std::out_of_range& e) {
8889       {
8890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (std::exception& e) {
8893       {
8894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (Dali::DaliException e) {
8897       {
8898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906
8907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8913   void * jresult ;
8914   Dali::Uint16Pair *result = 0 ;
8915
8916   {
8917     try {
8918       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8919     } catch (std::out_of_range& e) {
8920       {
8921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8922       };
8923     } catch (std::exception& e) {
8924       {
8925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8926       };
8927     } catch (Dali::DaliException e) {
8928       {
8929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8930       };
8931     } catch (...) {
8932       {
8933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8934       };
8935     }
8936   }
8937
8938   jresult = (void *)result;
8939   return jresult;
8940 }
8941
8942
8943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8944   void * jresult ;
8945   uint32_t arg1 ;
8946   uint32_t arg2 ;
8947   Dali::Uint16Pair *result = 0 ;
8948
8949   arg1 = (uint32_t)jarg1;
8950   arg2 = (uint32_t)jarg2;
8951   {
8952     try {
8953       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8954     } catch (std::out_of_range& e) {
8955       {
8956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8957       };
8958     } catch (std::exception& e) {
8959       {
8960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8961       };
8962     } catch (Dali::DaliException e) {
8963       {
8964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8965       };
8966     } catch (...) {
8967       {
8968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8969       };
8970     }
8971   }
8972
8973   jresult = (void *)result;
8974   return jresult;
8975 }
8976
8977
8978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8979   void * jresult ;
8980   Dali::Uint16Pair *arg1 = 0 ;
8981   Dali::Uint16Pair *result = 0 ;
8982
8983   arg1 = (Dali::Uint16Pair *)jarg1;
8984   if (!arg1) {
8985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8986     return 0;
8987   }
8988   {
8989     try {
8990       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8991     } catch (std::out_of_range& e) {
8992       {
8993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8994       };
8995     } catch (std::exception& e) {
8996       {
8997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8998       };
8999     } catch (Dali::DaliException e) {
9000       {
9001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9002       };
9003     } catch (...) {
9004       {
9005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9006       };
9007     }
9008   }
9009
9010   jresult = (void *)result;
9011   return jresult;
9012 }
9013
9014
9015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9016   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9017   uint16_t arg2 ;
9018
9019   arg1 = (Dali::Uint16Pair *)jarg1;
9020   arg2 = (uint16_t)jarg2;
9021   {
9022     try {
9023       (arg1)->SetWidth(arg2);
9024     } catch (std::out_of_range& e) {
9025       {
9026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9027       };
9028     } catch (std::exception& e) {
9029       {
9030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9031       };
9032     } catch (Dali::DaliException e) {
9033       {
9034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9035       };
9036     } catch (...) {
9037       {
9038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9039       };
9040     }
9041   }
9042
9043 }
9044
9045
9046 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9047   unsigned short jresult ;
9048   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9049   uint16_t result;
9050
9051   arg1 = (Dali::Uint16Pair *)jarg1;
9052   {
9053     try {
9054       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9055     } catch (std::out_of_range& e) {
9056       {
9057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9058       };
9059     } catch (std::exception& e) {
9060       {
9061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9062       };
9063     } catch (Dali::DaliException e) {
9064       {
9065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9066       };
9067     } catch (...) {
9068       {
9069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9070       };
9071     }
9072   }
9073
9074   jresult = result;
9075   return jresult;
9076 }
9077
9078
9079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9080   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9081   uint16_t arg2 ;
9082
9083   arg1 = (Dali::Uint16Pair *)jarg1;
9084   arg2 = (uint16_t)jarg2;
9085   {
9086     try {
9087       (arg1)->SetHeight(arg2);
9088     } catch (std::out_of_range& e) {
9089       {
9090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9091       };
9092     } catch (std::exception& e) {
9093       {
9094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9095       };
9096     } catch (Dali::DaliException e) {
9097       {
9098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9099       };
9100     } catch (...) {
9101       {
9102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9103       };
9104     }
9105   }
9106
9107 }
9108
9109
9110 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9111   unsigned short jresult ;
9112   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9113   uint16_t result;
9114
9115   arg1 = (Dali::Uint16Pair *)jarg1;
9116   {
9117     try {
9118       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9119     } catch (std::out_of_range& e) {
9120       {
9121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9122       };
9123     } catch (std::exception& e) {
9124       {
9125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9126       };
9127     } catch (Dali::DaliException e) {
9128       {
9129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9130       };
9131     } catch (...) {
9132       {
9133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9134       };
9135     }
9136   }
9137
9138   jresult = result;
9139   return jresult;
9140 }
9141
9142
9143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9144   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9145   uint16_t arg2 ;
9146
9147   arg1 = (Dali::Uint16Pair *)jarg1;
9148   arg2 = (uint16_t)jarg2;
9149   {
9150     try {
9151       (arg1)->SetX(arg2);
9152     } catch (std::out_of_range& e) {
9153       {
9154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9155       };
9156     } catch (std::exception& e) {
9157       {
9158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9159       };
9160     } catch (Dali::DaliException e) {
9161       {
9162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9163       };
9164     } catch (...) {
9165       {
9166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9167       };
9168     }
9169   }
9170
9171 }
9172
9173
9174 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9175   unsigned short jresult ;
9176   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9177   uint16_t result;
9178
9179   arg1 = (Dali::Uint16Pair *)jarg1;
9180   {
9181     try {
9182       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9183     } catch (std::out_of_range& e) {
9184       {
9185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9186       };
9187     } catch (std::exception& e) {
9188       {
9189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9190       };
9191     } catch (Dali::DaliException e) {
9192       {
9193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9194       };
9195     } catch (...) {
9196       {
9197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9198       };
9199     }
9200   }
9201
9202   jresult = result;
9203   return jresult;
9204 }
9205
9206
9207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9208   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9209   uint16_t arg2 ;
9210
9211   arg1 = (Dali::Uint16Pair *)jarg1;
9212   arg2 = (uint16_t)jarg2;
9213   {
9214     try {
9215       (arg1)->SetY(arg2);
9216     } catch (std::out_of_range& e) {
9217       {
9218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9219       };
9220     } catch (std::exception& e) {
9221       {
9222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9223       };
9224     } catch (Dali::DaliException e) {
9225       {
9226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9227       };
9228     } catch (...) {
9229       {
9230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9231       };
9232     }
9233   }
9234
9235 }
9236
9237
9238 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9239   unsigned short jresult ;
9240   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9241   uint16_t result;
9242
9243   arg1 = (Dali::Uint16Pair *)jarg1;
9244   {
9245     try {
9246       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9247     } catch (std::out_of_range& e) {
9248       {
9249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9250       };
9251     } catch (std::exception& e) {
9252       {
9253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9254       };
9255     } catch (Dali::DaliException e) {
9256       {
9257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9258       };
9259     } catch (...) {
9260       {
9261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9262       };
9263     }
9264   }
9265
9266   jresult = result;
9267   return jresult;
9268 }
9269
9270
9271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9272   void * jresult ;
9273   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9274   Dali::Uint16Pair *arg2 = 0 ;
9275   Dali::Uint16Pair *result = 0 ;
9276
9277   arg1 = (Dali::Uint16Pair *)jarg1;
9278   arg2 = (Dali::Uint16Pair *)jarg2;
9279   if (!arg2) {
9280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9281     return 0;
9282   }
9283   {
9284     try {
9285       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9286     } catch (std::out_of_range& e) {
9287       {
9288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9289       };
9290     } catch (std::exception& e) {
9291       {
9292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9293       };
9294     } catch (Dali::DaliException e) {
9295       {
9296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9297       };
9298     } catch (...) {
9299       {
9300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9301       };
9302     }
9303   }
9304
9305   jresult = (void *)result;
9306   return jresult;
9307 }
9308
9309
9310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9311   unsigned int jresult ;
9312   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9313   Dali::Uint16Pair *arg2 = 0 ;
9314   bool result;
9315
9316   arg1 = (Dali::Uint16Pair *)jarg1;
9317   arg2 = (Dali::Uint16Pair *)jarg2;
9318   if (!arg2) {
9319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9320     return 0;
9321   }
9322   {
9323     try {
9324       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9325     } catch (std::out_of_range& e) {
9326       {
9327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9328       };
9329     } catch (std::exception& e) {
9330       {
9331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9332       };
9333     } catch (Dali::DaliException e) {
9334       {
9335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9336       };
9337     } catch (...) {
9338       {
9339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9340       };
9341     }
9342   }
9343
9344   jresult = result;
9345   return jresult;
9346 }
9347
9348
9349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9350   unsigned int jresult ;
9351   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9352   Dali::Uint16Pair *arg2 = 0 ;
9353   bool result;
9354
9355   arg1 = (Dali::Uint16Pair *)jarg1;
9356   arg2 = (Dali::Uint16Pair *)jarg2;
9357   if (!arg2) {
9358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9359     return 0;
9360   }
9361   {
9362     try {
9363       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9364     } catch (std::out_of_range& e) {
9365       {
9366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9367       };
9368     } catch (std::exception& e) {
9369       {
9370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (Dali::DaliException e) {
9373       {
9374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9375       };
9376     } catch (...) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9379       };
9380     }
9381   }
9382
9383   jresult = result;
9384   return jresult;
9385 }
9386
9387
9388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9389   unsigned int jresult ;
9390   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9391   Dali::Uint16Pair *arg2 = 0 ;
9392   bool result;
9393
9394   arg1 = (Dali::Uint16Pair *)jarg1;
9395   arg2 = (Dali::Uint16Pair *)jarg2;
9396   if (!arg2) {
9397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9398     return 0;
9399   }
9400   {
9401     try {
9402       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9403     } catch (std::out_of_range& e) {
9404       {
9405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9406       };
9407     } catch (std::exception& e) {
9408       {
9409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9410       };
9411     } catch (Dali::DaliException e) {
9412       {
9413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9414       };
9415     } catch (...) {
9416       {
9417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9418       };
9419     }
9420   }
9421
9422   jresult = result;
9423   return jresult;
9424 }
9425
9426
9427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9428   unsigned int jresult ;
9429   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9430   Dali::Uint16Pair *arg2 = 0 ;
9431   bool result;
9432
9433   arg1 = (Dali::Uint16Pair *)jarg1;
9434   arg2 = (Dali::Uint16Pair *)jarg2;
9435   if (!arg2) {
9436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9437     return 0;
9438   }
9439   {
9440     try {
9441       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9442     } catch (std::out_of_range& e) {
9443       {
9444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9445       };
9446     } catch (std::exception& e) {
9447       {
9448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9449       };
9450     } catch (Dali::DaliException e) {
9451       {
9452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9453       };
9454     } catch (...) {
9455       {
9456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9457       };
9458     }
9459   }
9460
9461   jresult = result;
9462   return jresult;
9463 }
9464
9465
9466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9467   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9468
9469   arg1 = (Dali::Uint16Pair *)jarg1;
9470   {
9471     try {
9472       delete arg1;
9473     } catch (std::out_of_range& e) {
9474       {
9475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9476       };
9477     } catch (std::exception& e) {
9478       {
9479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9480       };
9481     } catch (Dali::DaliException e) {
9482       {
9483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9484       };
9485     } catch (...) {
9486       {
9487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9488       };
9489     }
9490   }
9491
9492 }
9493
9494
9495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9496   void * jresult ;
9497   Dali::Degree *result = 0 ;
9498
9499   {
9500     try {
9501       result = (Dali::Degree *)new Dali::Degree();
9502     } catch (std::out_of_range& e) {
9503       {
9504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9505       };
9506     } catch (std::exception& e) {
9507       {
9508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9509       };
9510     } catch (Dali::DaliException e) {
9511       {
9512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9513       };
9514     } catch (...) {
9515       {
9516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9517       };
9518     }
9519   }
9520
9521   jresult = (void *)result;
9522   return jresult;
9523 }
9524
9525
9526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9527   void * jresult ;
9528   float arg1 ;
9529   Dali::Degree *result = 0 ;
9530
9531   arg1 = (float)jarg1;
9532   {
9533     try {
9534       result = (Dali::Degree *)new Dali::Degree(arg1);
9535     } catch (std::out_of_range& e) {
9536       {
9537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9538       };
9539     } catch (std::exception& e) {
9540       {
9541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9542       };
9543     } catch (Dali::DaliException e) {
9544       {
9545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9546       };
9547     } catch (...) {
9548       {
9549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9550       };
9551     }
9552   }
9553
9554   jresult = (void *)result;
9555   return jresult;
9556 }
9557
9558
9559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9560   void * jresult ;
9561   Dali::Radian arg1 ;
9562   Dali::Radian *argp1 ;
9563   Dali::Degree *result = 0 ;
9564
9565   argp1 = (Dali::Radian *)jarg1;
9566   if (!argp1) {
9567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9568     return 0;
9569   }
9570   arg1 = *argp1;
9571   {
9572     try {
9573       result = (Dali::Degree *)new Dali::Degree(arg1);
9574     } catch (std::out_of_range& e) {
9575       {
9576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9577       };
9578     } catch (std::exception& e) {
9579       {
9580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (Dali::DaliException e) {
9583       {
9584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9585       };
9586     } catch (...) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9589       };
9590     }
9591   }
9592
9593   jresult = (void *)result;
9594   return jresult;
9595 }
9596
9597
9598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9599   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9600   float arg2 ;
9601
9602   arg1 = (Dali::Degree *)jarg1;
9603   arg2 = (float)jarg2;
9604   if (arg1) (arg1)->degree = arg2;
9605 }
9606
9607
9608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9609   float jresult ;
9610   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9611   float result;
9612
9613   arg1 = (Dali::Degree *)jarg1;
9614   result = (float) ((arg1)->degree);
9615   jresult = result;
9616   return jresult;
9617 }
9618
9619
9620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9621   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9622
9623   arg1 = (Dali::Degree *)jarg1;
9624   {
9625     try {
9626       delete arg1;
9627     } catch (std::out_of_range& e) {
9628       {
9629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9630       };
9631     } catch (std::exception& e) {
9632       {
9633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9634       };
9635     } catch (Dali::DaliException e) {
9636       {
9637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9638       };
9639     } catch (...) {
9640       {
9641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9642       };
9643     }
9644   }
9645
9646 }
9647
9648
9649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9650   void * jresult ;
9651   Dali::Radian *result = 0 ;
9652
9653   result = (Dali::Radian *)&Dali::ANGLE_360;
9654   jresult = (void *)result;
9655   return jresult;
9656 }
9657
9658
9659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9660   void * jresult ;
9661   Dali::Radian *result = 0 ;
9662
9663   result = (Dali::Radian *)&Dali::ANGLE_315;
9664   jresult = (void *)result;
9665   return jresult;
9666 }
9667
9668
9669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9670   void * jresult ;
9671   Dali::Radian *result = 0 ;
9672
9673   result = (Dali::Radian *)&Dali::ANGLE_270;
9674   jresult = (void *)result;
9675   return jresult;
9676 }
9677
9678
9679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9680   void * jresult ;
9681   Dali::Radian *result = 0 ;
9682
9683   result = (Dali::Radian *)&Dali::ANGLE_225;
9684   jresult = (void *)result;
9685   return jresult;
9686 }
9687
9688
9689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9690   void * jresult ;
9691   Dali::Radian *result = 0 ;
9692
9693   result = (Dali::Radian *)&Dali::ANGLE_180;
9694   jresult = (void *)result;
9695   return jresult;
9696 }
9697
9698
9699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9700   void * jresult ;
9701   Dali::Radian *result = 0 ;
9702
9703   result = (Dali::Radian *)&Dali::ANGLE_135;
9704   jresult = (void *)result;
9705   return jresult;
9706 }
9707
9708
9709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9710   void * jresult ;
9711   Dali::Radian *result = 0 ;
9712
9713   result = (Dali::Radian *)&Dali::ANGLE_120;
9714   jresult = (void *)result;
9715   return jresult;
9716 }
9717
9718
9719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9720   void * jresult ;
9721   Dali::Radian *result = 0 ;
9722
9723   result = (Dali::Radian *)&Dali::ANGLE_90;
9724   jresult = (void *)result;
9725   return jresult;
9726 }
9727
9728
9729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9730   void * jresult ;
9731   Dali::Radian *result = 0 ;
9732
9733   result = (Dali::Radian *)&Dali::ANGLE_60;
9734   jresult = (void *)result;
9735   return jresult;
9736 }
9737
9738
9739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9740   void * jresult ;
9741   Dali::Radian *result = 0 ;
9742
9743   result = (Dali::Radian *)&Dali::ANGLE_45;
9744   jresult = (void *)result;
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9750   void * jresult ;
9751   Dali::Radian *result = 0 ;
9752
9753   result = (Dali::Radian *)&Dali::ANGLE_30;
9754   jresult = (void *)result;
9755   return jresult;
9756 }
9757
9758
9759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9760   void * jresult ;
9761   Dali::Radian *result = 0 ;
9762
9763   result = (Dali::Radian *)&Dali::ANGLE_0;
9764   jresult = (void *)result;
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9770   unsigned int jresult ;
9771   Dali::Degree *arg1 = 0 ;
9772   Dali::Degree *arg2 = 0 ;
9773   bool result;
9774
9775   arg1 = (Dali::Degree *)jarg1;
9776   if (!arg1) {
9777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9778     return 0;
9779   }
9780   arg2 = (Dali::Degree *)jarg2;
9781   if (!arg2) {
9782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9783     return 0;
9784   }
9785   {
9786     try {
9787       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9788     } catch (std::out_of_range& e) {
9789       {
9790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9791       };
9792     } catch (std::exception& e) {
9793       {
9794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9795       };
9796     } catch (Dali::DaliException e) {
9797       {
9798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9799       };
9800     } catch (...) {
9801       {
9802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9803       };
9804     }
9805   }
9806
9807   jresult = result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9813   unsigned int jresult ;
9814   Dali::Degree *arg1 = 0 ;
9815   Dali::Degree *arg2 = 0 ;
9816   bool result;
9817
9818   arg1 = (Dali::Degree *)jarg1;
9819   if (!arg1) {
9820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9821     return 0;
9822   }
9823   arg2 = (Dali::Degree *)jarg2;
9824   if (!arg2) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   {
9829     try {
9830       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9831     } catch (std::out_of_range& e) {
9832       {
9833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9834       };
9835     } catch (std::exception& e) {
9836       {
9837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (Dali::DaliException e) {
9840       {
9841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9842       };
9843     } catch (...) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9846       };
9847     }
9848   }
9849
9850   jresult = result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9856   void * jresult ;
9857   Dali::Degree arg1 ;
9858   float arg2 ;
9859   float arg3 ;
9860   Dali::Degree *argp1 ;
9861   Dali::Degree result;
9862
9863   argp1 = (Dali::Degree *)jarg1;
9864   if (!argp1) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9866     return 0;
9867   }
9868   arg1 = *argp1;
9869   arg2 = (float)jarg2;
9870   arg3 = (float)jarg3;
9871   {
9872     try {
9873       result = Dali::Clamp(arg1,arg2,arg3);
9874     } catch (std::out_of_range& e) {
9875       {
9876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9877       };
9878     } catch (std::exception& e) {
9879       {
9880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (Dali::DaliException e) {
9883       {
9884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9885       };
9886     } catch (...) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9889       };
9890     }
9891   }
9892
9893   jresult = new Dali::Degree((const Dali::Degree &)result);
9894   return jresult;
9895 }
9896
9897
9898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9899   void * jresult ;
9900   Dali::Radian *result = 0 ;
9901
9902   {
9903     try {
9904       result = (Dali::Radian *)new Dali::Radian();
9905     } catch (std::out_of_range& e) {
9906       {
9907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9908       };
9909     } catch (std::exception& e) {
9910       {
9911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9912       };
9913     } catch (Dali::DaliException e) {
9914       {
9915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9916       };
9917     } catch (...) {
9918       {
9919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9920       };
9921     }
9922   }
9923
9924   jresult = (void *)result;
9925   return jresult;
9926 }
9927
9928
9929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9930   void * jresult ;
9931   float arg1 ;
9932   Dali::Radian *result = 0 ;
9933
9934   arg1 = (float)jarg1;
9935   {
9936     try {
9937       result = (Dali::Radian *)new Dali::Radian(arg1);
9938     } catch (std::out_of_range& e) {
9939       {
9940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (std::exception& e) {
9943       {
9944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9945       };
9946     } catch (Dali::DaliException e) {
9947       {
9948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9949       };
9950     } catch (...) {
9951       {
9952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9953       };
9954     }
9955   }
9956
9957   jresult = (void *)result;
9958   return jresult;
9959 }
9960
9961
9962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9963   void * jresult ;
9964   Dali::Degree arg1 ;
9965   Dali::Degree *argp1 ;
9966   Dali::Radian *result = 0 ;
9967
9968   argp1 = (Dali::Degree *)jarg1;
9969   if (!argp1) {
9970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9971     return 0;
9972   }
9973   arg1 = *argp1;
9974   {
9975     try {
9976       result = (Dali::Radian *)new Dali::Radian(arg1);
9977     } catch (std::out_of_range& e) {
9978       {
9979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9980       };
9981     } catch (std::exception& e) {
9982       {
9983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9984       };
9985     } catch (Dali::DaliException e) {
9986       {
9987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9988       };
9989     } catch (...) {
9990       {
9991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9992       };
9993     }
9994   }
9995
9996   jresult = (void *)result;
9997   return jresult;
9998 }
9999
10000
10001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10002   void * jresult ;
10003   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10004   float arg2 ;
10005   Dali::Radian *result = 0 ;
10006
10007   arg1 = (Dali::Radian *)jarg1;
10008   arg2 = (float)jarg2;
10009   {
10010     try {
10011       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10012     } catch (std::out_of_range& e) {
10013       {
10014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10015       };
10016     } catch (std::exception& e) {
10017       {
10018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10019       };
10020     } catch (Dali::DaliException e) {
10021       {
10022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10023       };
10024     } catch (...) {
10025       {
10026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10027       };
10028     }
10029   }
10030
10031   jresult = (void *)result;
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10037   void * jresult ;
10038   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10039   Dali::Degree arg2 ;
10040   Dali::Degree *argp2 ;
10041   Dali::Radian *result = 0 ;
10042
10043   arg1 = (Dali::Radian *)jarg1;
10044   argp2 = (Dali::Degree *)jarg2;
10045   if (!argp2) {
10046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10047     return 0;
10048   }
10049   arg2 = *argp2;
10050   {
10051     try {
10052       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10053     } catch (std::out_of_range& e) {
10054       {
10055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10056       };
10057     } catch (std::exception& e) {
10058       {
10059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (Dali::DaliException e) {
10062       {
10063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10064       };
10065     } catch (...) {
10066       {
10067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10068       };
10069     }
10070   }
10071
10072   jresult = (void *)result;
10073   return jresult;
10074 }
10075
10076
10077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10078   float jresult ;
10079   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10080   float result;
10081
10082   arg1 = (Dali::Radian *)jarg1;
10083   {
10084     try {
10085       result = (float)((Dali::Radian const *)arg1)->operator float();
10086     } catch (std::out_of_range& e) {
10087       {
10088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10089       };
10090     } catch (std::exception& e) {
10091       {
10092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10093       };
10094     } catch (Dali::DaliException e) {
10095       {
10096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10097       };
10098     } catch (...) {
10099       {
10100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10101       };
10102     }
10103   }
10104
10105   jresult = result;
10106   return jresult;
10107 }
10108
10109
10110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10111   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10112   float arg2 ;
10113
10114   arg1 = (Dali::Radian *)jarg1;
10115   arg2 = (float)jarg2;
10116   if (arg1) (arg1)->radian = arg2;
10117 }
10118
10119
10120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10121   float jresult ;
10122   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10123   float result;
10124
10125   arg1 = (Dali::Radian *)jarg1;
10126   result = (float) ((arg1)->radian);
10127   jresult = result;
10128   return jresult;
10129 }
10130
10131
10132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10133   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10134
10135   arg1 = (Dali::Radian *)jarg1;
10136   {
10137     try {
10138       delete arg1;
10139     } catch (std::out_of_range& e) {
10140       {
10141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10142       };
10143     } catch (std::exception& e) {
10144       {
10145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10146       };
10147     } catch (Dali::DaliException e) {
10148       {
10149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10150       };
10151     } catch (...) {
10152       {
10153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10154       };
10155     }
10156   }
10157
10158 }
10159
10160
10161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10162   unsigned int jresult ;
10163   Dali::Radian arg1 ;
10164   Dali::Radian arg2 ;
10165   Dali::Radian *argp1 ;
10166   Dali::Radian *argp2 ;
10167   bool result;
10168
10169   argp1 = (Dali::Radian *)jarg1;
10170   if (!argp1) {
10171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10172     return 0;
10173   }
10174   arg1 = *argp1;
10175   argp2 = (Dali::Radian *)jarg2;
10176   if (!argp2) {
10177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10178     return 0;
10179   }
10180   arg2 = *argp2;
10181   {
10182     try {
10183       result = (bool)Dali::operator ==(arg1,arg2);
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10199       };
10200     }
10201   }
10202
10203   jresult = result;
10204   return jresult;
10205 }
10206
10207
10208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10209   unsigned int jresult ;
10210   Dali::Radian arg1 ;
10211   Dali::Radian arg2 ;
10212   Dali::Radian *argp1 ;
10213   Dali::Radian *argp2 ;
10214   bool result;
10215
10216   argp1 = (Dali::Radian *)jarg1;
10217   if (!argp1) {
10218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10219     return 0;
10220   }
10221   arg1 = *argp1;
10222   argp2 = (Dali::Radian *)jarg2;
10223   if (!argp2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10225     return 0;
10226   }
10227   arg2 = *argp2;
10228   {
10229     try {
10230       result = (bool)Dali::operator !=(arg1,arg2);
10231     } catch (std::out_of_range& e) {
10232       {
10233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (std::exception& e) {
10236       {
10237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10238       };
10239     } catch (Dali::DaliException e) {
10240       {
10241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10242       };
10243     } catch (...) {
10244       {
10245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10246       };
10247     }
10248   }
10249
10250   jresult = result;
10251   return jresult;
10252 }
10253
10254
10255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10256   unsigned int jresult ;
10257   Dali::Radian arg1 ;
10258   Dali::Degree arg2 ;
10259   Dali::Radian *argp1 ;
10260   Dali::Degree *argp2 ;
10261   bool result;
10262
10263   argp1 = (Dali::Radian *)jarg1;
10264   if (!argp1) {
10265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10266     return 0;
10267   }
10268   arg1 = *argp1;
10269   argp2 = (Dali::Degree *)jarg2;
10270   if (!argp2) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10272     return 0;
10273   }
10274   arg2 = *argp2;
10275   {
10276     try {
10277       result = (bool)Dali::operator ==(arg1,arg2);
10278     } catch (std::out_of_range& e) {
10279       {
10280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (std::exception& e) {
10283       {
10284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (Dali::DaliException e) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10289       };
10290     } catch (...) {
10291       {
10292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10293       };
10294     }
10295   }
10296
10297   jresult = result;
10298   return jresult;
10299 }
10300
10301
10302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10303   unsigned int jresult ;
10304   Dali::Radian arg1 ;
10305   Dali::Degree arg2 ;
10306   Dali::Radian *argp1 ;
10307   Dali::Degree *argp2 ;
10308   bool result;
10309
10310   argp1 = (Dali::Radian *)jarg1;
10311   if (!argp1) {
10312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10313     return 0;
10314   }
10315   arg1 = *argp1;
10316   argp2 = (Dali::Degree *)jarg2;
10317   if (!argp2) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10319     return 0;
10320   }
10321   arg2 = *argp2;
10322   {
10323     try {
10324       result = (bool)Dali::operator !=(arg1,arg2);
10325     } catch (std::out_of_range& e) {
10326       {
10327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (std::exception& e) {
10330       {
10331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (Dali::DaliException e) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10336       };
10337     } catch (...) {
10338       {
10339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10340       };
10341     }
10342   }
10343
10344   jresult = result;
10345   return jresult;
10346 }
10347
10348
10349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10350   unsigned int jresult ;
10351   Dali::Degree arg1 ;
10352   Dali::Radian arg2 ;
10353   Dali::Degree *argp1 ;
10354   Dali::Radian *argp2 ;
10355   bool result;
10356
10357   argp1 = (Dali::Degree *)jarg1;
10358   if (!argp1) {
10359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10360     return 0;
10361   }
10362   arg1 = *argp1;
10363   argp2 = (Dali::Radian *)jarg2;
10364   if (!argp2) {
10365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10366     return 0;
10367   }
10368   arg2 = *argp2;
10369   {
10370     try {
10371       result = (bool)Dali::operator ==(arg1,arg2);
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (Dali::DaliException e) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10383       };
10384     } catch (...) {
10385       {
10386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10387       };
10388     }
10389   }
10390
10391   jresult = result;
10392   return jresult;
10393 }
10394
10395
10396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10397   unsigned int jresult ;
10398   Dali::Degree arg1 ;
10399   Dali::Radian arg2 ;
10400   Dali::Degree *argp1 ;
10401   Dali::Radian *argp2 ;
10402   bool result;
10403
10404   argp1 = (Dali::Degree *)jarg1;
10405   if (!argp1) {
10406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10407     return 0;
10408   }
10409   arg1 = *argp1;
10410   argp2 = (Dali::Radian *)jarg2;
10411   if (!argp2) {
10412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10413     return 0;
10414   }
10415   arg2 = *argp2;
10416   {
10417     try {
10418       result = (bool)Dali::operator !=(arg1,arg2);
10419     } catch (std::out_of_range& e) {
10420       {
10421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (std::exception& e) {
10424       {
10425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (Dali::DaliException e) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10430       };
10431     } catch (...) {
10432       {
10433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10434       };
10435     }
10436   }
10437
10438   jresult = result;
10439   return jresult;
10440 }
10441
10442
10443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10444   unsigned int jresult ;
10445   Dali::Radian arg1 ;
10446   Dali::Radian arg2 ;
10447   Dali::Radian *argp1 ;
10448   Dali::Radian *argp2 ;
10449   bool result;
10450
10451   argp1 = (Dali::Radian *)jarg1;
10452   if (!argp1) {
10453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10454     return 0;
10455   }
10456   arg1 = *argp1;
10457   argp2 = (Dali::Radian *)jarg2;
10458   if (!argp2) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10460     return 0;
10461   }
10462   arg2 = *argp2;
10463   {
10464     try {
10465       result = (bool)Dali::operator >(arg1,arg2);
10466     } catch (std::out_of_range& e) {
10467       {
10468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (std::exception& e) {
10471       {
10472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10473       };
10474     } catch (Dali::DaliException e) {
10475       {
10476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10477       };
10478     } catch (...) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10481       };
10482     }
10483   }
10484
10485   jresult = result;
10486   return jresult;
10487 }
10488
10489
10490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10491   unsigned int jresult ;
10492   Dali::Radian arg1 ;
10493   Dali::Degree arg2 ;
10494   Dali::Radian *argp1 ;
10495   Dali::Degree *argp2 ;
10496   bool result;
10497
10498   argp1 = (Dali::Radian *)jarg1;
10499   if (!argp1) {
10500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10501     return 0;
10502   }
10503   arg1 = *argp1;
10504   argp2 = (Dali::Degree *)jarg2;
10505   if (!argp2) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10507     return 0;
10508   }
10509   arg2 = *argp2;
10510   {
10511     try {
10512       result = (bool)Dali::operator >(arg1,arg2);
10513     } catch (std::out_of_range& e) {
10514       {
10515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (std::exception& e) {
10518       {
10519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10520       };
10521     } catch (Dali::DaliException e) {
10522       {
10523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10524       };
10525     } catch (...) {
10526       {
10527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10528       };
10529     }
10530   }
10531
10532   jresult = result;
10533   return jresult;
10534 }
10535
10536
10537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10538   unsigned int jresult ;
10539   Dali::Degree arg1 ;
10540   Dali::Radian arg2 ;
10541   Dali::Degree *argp1 ;
10542   Dali::Radian *argp2 ;
10543   bool result;
10544
10545   argp1 = (Dali::Degree *)jarg1;
10546   if (!argp1) {
10547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10548     return 0;
10549   }
10550   arg1 = *argp1;
10551   argp2 = (Dali::Radian *)jarg2;
10552   if (!argp2) {
10553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10554     return 0;
10555   }
10556   arg2 = *argp2;
10557   {
10558     try {
10559       result = (bool)Dali::operator >(arg1,arg2);
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10567       };
10568     } catch (Dali::DaliException e) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10571       };
10572     } catch (...) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10575       };
10576     }
10577   }
10578
10579   jresult = result;
10580   return jresult;
10581 }
10582
10583
10584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10585   unsigned int jresult ;
10586   Dali::Radian arg1 ;
10587   Dali::Radian arg2 ;
10588   Dali::Radian *argp1 ;
10589   Dali::Radian *argp2 ;
10590   bool result;
10591
10592   argp1 = (Dali::Radian *)jarg1;
10593   if (!argp1) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10595     return 0;
10596   }
10597   arg1 = *argp1;
10598   argp2 = (Dali::Radian *)jarg2;
10599   if (!argp2) {
10600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10601     return 0;
10602   }
10603   arg2 = *argp2;
10604   {
10605     try {
10606       result = (bool)Dali::operator <(arg1,arg2);
10607     } catch (std::out_of_range& e) {
10608       {
10609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (std::exception& e) {
10612       {
10613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (Dali::DaliException e) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10618       };
10619     } catch (...) {
10620       {
10621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10622       };
10623     }
10624   }
10625
10626   jresult = result;
10627   return jresult;
10628 }
10629
10630
10631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10632   unsigned int jresult ;
10633   Dali::Radian arg1 ;
10634   Dali::Degree arg2 ;
10635   Dali::Radian *argp1 ;
10636   Dali::Degree *argp2 ;
10637   bool result;
10638
10639   argp1 = (Dali::Radian *)jarg1;
10640   if (!argp1) {
10641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10642     return 0;
10643   }
10644   arg1 = *argp1;
10645   argp2 = (Dali::Degree *)jarg2;
10646   if (!argp2) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10648     return 0;
10649   }
10650   arg2 = *argp2;
10651   {
10652     try {
10653       result = (bool)Dali::operator <(arg1,arg2);
10654     } catch (std::out_of_range& e) {
10655       {
10656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (std::exception& e) {
10659       {
10660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10661       };
10662     } catch (Dali::DaliException e) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10665       };
10666     } catch (...) {
10667       {
10668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10669       };
10670     }
10671   }
10672
10673   jresult = result;
10674   return jresult;
10675 }
10676
10677
10678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10679   unsigned int jresult ;
10680   Dali::Degree arg1 ;
10681   Dali::Radian arg2 ;
10682   Dali::Degree *argp1 ;
10683   Dali::Radian *argp2 ;
10684   bool result;
10685
10686   argp1 = (Dali::Degree *)jarg1;
10687   if (!argp1) {
10688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10689     return 0;
10690   }
10691   arg1 = *argp1;
10692   argp2 = (Dali::Radian *)jarg2;
10693   if (!argp2) {
10694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10695     return 0;
10696   }
10697   arg2 = *argp2;
10698   {
10699     try {
10700       result = (bool)Dali::operator <(arg1,arg2);
10701     } catch (std::out_of_range& e) {
10702       {
10703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10704       };
10705     } catch (std::exception& e) {
10706       {
10707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10708       };
10709     } catch (Dali::DaliException e) {
10710       {
10711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10712       };
10713     } catch (...) {
10714       {
10715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10716       };
10717     }
10718   }
10719
10720   jresult = result;
10721   return jresult;
10722 }
10723
10724
10725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10726   void * jresult ;
10727   Dali::Radian arg1 ;
10728   float arg2 ;
10729   Dali::Radian *argp1 ;
10730   Dali::Radian result;
10731
10732   argp1 = (Dali::Radian *)jarg1;
10733   if (!argp1) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10735     return 0;
10736   }
10737   arg1 = *argp1;
10738   arg2 = (float)jarg2;
10739   {
10740     try {
10741       result = Dali::operator *(arg1,arg2);
10742     } catch (std::out_of_range& e) {
10743       {
10744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10745       };
10746     } catch (std::exception& e) {
10747       {
10748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (Dali::DaliException e) {
10751       {
10752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10753       };
10754     } catch (...) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10757       };
10758     }
10759   }
10760
10761   jresult = new Dali::Radian((const Dali::Radian &)result);
10762   return jresult;
10763 }
10764
10765
10766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10767   void * jresult ;
10768   Dali::Radian arg1 ;
10769   Dali::Radian *argp1 ;
10770   Dali::Radian result;
10771
10772   argp1 = (Dali::Radian *)jarg1;
10773   if (!argp1) {
10774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10775     return 0;
10776   }
10777   arg1 = *argp1;
10778   {
10779     try {
10780       result = Dali::operator -(arg1);
10781     } catch (std::out_of_range& e) {
10782       {
10783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10784       };
10785     } catch (std::exception& e) {
10786       {
10787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10788       };
10789     } catch (Dali::DaliException e) {
10790       {
10791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10792       };
10793     } catch (...) {
10794       {
10795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10796       };
10797     }
10798   }
10799
10800   jresult = new Dali::Radian((const Dali::Radian &)result);
10801   return jresult;
10802 }
10803
10804
10805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10806   void * jresult ;
10807   Dali::Radian arg1 ;
10808   float arg2 ;
10809   float arg3 ;
10810   Dali::Radian *argp1 ;
10811   Dali::Radian result;
10812
10813   argp1 = (Dali::Radian *)jarg1;
10814   if (!argp1) {
10815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10816     return 0;
10817   }
10818   arg1 = *argp1;
10819   arg2 = (float)jarg2;
10820   arg3 = (float)jarg3;
10821   {
10822     try {
10823       result = Dali::Clamp(arg1,arg2,arg3);
10824     } catch (std::out_of_range& e) {
10825       {
10826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10827       };
10828     } catch (std::exception& e) {
10829       {
10830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (Dali::DaliException e) {
10833       {
10834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842
10843   jresult = new Dali::Radian((const Dali::Radian &)result);
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10849   void * jresult ;
10850   Dali::Quaternion *result = 0 ;
10851
10852   {
10853     try {
10854       result = (Dali::Quaternion *)new Dali::Quaternion();
10855     } catch (std::out_of_range& e) {
10856       {
10857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10858       };
10859     } catch (std::exception& e) {
10860       {
10861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10862       };
10863     } catch (Dali::DaliException e) {
10864       {
10865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10866       };
10867     } catch (...) {
10868       {
10869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10870       };
10871     }
10872   }
10873
10874   jresult = (void *)result;
10875   return jresult;
10876 }
10877
10878
10879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10880   void * jresult ;
10881   Dali::Radian arg1 ;
10882   Dali::Vector3 *arg2 = 0 ;
10883   Dali::Radian *argp1 ;
10884   Dali::Quaternion *result = 0 ;
10885
10886   argp1 = (Dali::Radian *)jarg1;
10887   if (!argp1) {
10888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10889     return 0;
10890   }
10891   arg1 = *argp1;
10892   arg2 = (Dali::Vector3 *)jarg2;
10893   if (!arg2) {
10894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10895     return 0;
10896   }
10897   {
10898     try {
10899       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (Dali::DaliException e) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10911       };
10912     } catch (...) {
10913       {
10914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10915       };
10916     }
10917   }
10918
10919   jresult = (void *)result;
10920   return jresult;
10921 }
10922
10923
10924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10925   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10926
10927   arg1 = (Dali::Quaternion *)jarg1;
10928   {
10929     try {
10930       delete arg1;
10931     } catch (std::out_of_range& e) {
10932       {
10933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10934       };
10935     } catch (std::exception& e) {
10936       {
10937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10938       };
10939     } catch (Dali::DaliException e) {
10940       {
10941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10942       };
10943     } catch (...) {
10944       {
10945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10946       };
10947     }
10948   }
10949
10950 }
10951
10952
10953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10954   void * jresult ;
10955   Dali::Quaternion *result = 0 ;
10956
10957   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10958   jresult = (void *)result;
10959   return jresult;
10960 }
10961
10962
10963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10964   unsigned int jresult ;
10965   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10966   bool result;
10967
10968   arg1 = (Dali::Quaternion *)jarg1;
10969   {
10970     try {
10971       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10972     } catch (std::out_of_range& e) {
10973       {
10974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10975       };
10976     } catch (std::exception& e) {
10977       {
10978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10979       };
10980     } catch (Dali::DaliException e) {
10981       {
10982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10983       };
10984     } catch (...) {
10985       {
10986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10987       };
10988     }
10989   }
10990
10991   jresult = result;
10992   return jresult;
10993 }
10994
10995
10996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10997   unsigned int jresult ;
10998   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10999   Dali::Vector3 *arg2 = 0 ;
11000   Dali::Radian *arg3 = 0 ;
11001   bool result;
11002
11003   arg1 = (Dali::Quaternion *)jarg1;
11004   arg2 = (Dali::Vector3 *)jarg2;
11005   if (!arg2) {
11006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11007     return 0;
11008   }
11009   arg3 = (Dali::Radian *)jarg3;
11010   if (!arg3) {
11011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11012     return 0;
11013   }
11014   {
11015     try {
11016       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11017     } catch (std::out_of_range& e) {
11018       {
11019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11020       };
11021     } catch (std::exception& e) {
11022       {
11023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11024       };
11025     } catch (Dali::DaliException e) {
11026       {
11027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11032       };
11033     }
11034   }
11035
11036   jresult = result;
11037   return jresult;
11038 }
11039
11040
11041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11042   void * jresult ;
11043   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11044   Dali::Quaternion *arg2 = 0 ;
11045   Dali::Quaternion result;
11046
11047   arg1 = (Dali::Quaternion *)jarg1;
11048   arg2 = (Dali::Quaternion *)jarg2;
11049   if (!arg2) {
11050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11051     return 0;
11052   }
11053   {
11054     try {
11055       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11056     } catch (std::out_of_range& e) {
11057       {
11058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11059       };
11060     } catch (std::exception& e) {
11061       {
11062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11063       };
11064     } catch (Dali::DaliException e) {
11065       {
11066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11067       };
11068     } catch (...) {
11069       {
11070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11071       };
11072     }
11073   }
11074
11075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11076   return jresult;
11077 }
11078
11079
11080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11081   void * jresult ;
11082   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11083   Dali::Quaternion *arg2 = 0 ;
11084   Dali::Quaternion result;
11085
11086   arg1 = (Dali::Quaternion *)jarg1;
11087   arg2 = (Dali::Quaternion *)jarg2;
11088   if (!arg2) {
11089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11090     return 0;
11091   }
11092   {
11093     try {
11094       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11095     } catch (std::out_of_range& e) {
11096       {
11097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11098       };
11099     } catch (std::exception& e) {
11100       {
11101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11102       };
11103     } catch (Dali::DaliException e) {
11104       {
11105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11106       };
11107     } catch (...) {
11108       {
11109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11110       };
11111     }
11112   }
11113
11114   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11115   return jresult;
11116 }
11117
11118
11119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11120   void * jresult ;
11121   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11122   Dali::Quaternion *arg2 = 0 ;
11123   Dali::Quaternion result;
11124
11125   arg1 = (Dali::Quaternion *)jarg1;
11126   arg2 = (Dali::Quaternion *)jarg2;
11127   if (!arg2) {
11128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11129     return 0;
11130   }
11131   {
11132     try {
11133       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11134     } catch (std::out_of_range& e) {
11135       {
11136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11137       };
11138     } catch (std::exception& e) {
11139       {
11140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11141       };
11142     } catch (Dali::DaliException e) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11145       };
11146     } catch (...) {
11147       {
11148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11149       };
11150     }
11151   }
11152
11153   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11154   return jresult;
11155 }
11156
11157
11158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11159   void * jresult ;
11160   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11161   Dali::Vector3 *arg2 = 0 ;
11162   Dali::Vector3 result;
11163
11164   arg1 = (Dali::Quaternion *)jarg1;
11165   arg2 = (Dali::Vector3 *)jarg2;
11166   if (!arg2) {
11167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11168     return 0;
11169   }
11170   {
11171     try {
11172       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11173     } catch (std::out_of_range& e) {
11174       {
11175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (std::exception& e) {
11178       {
11179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11180       };
11181     } catch (Dali::DaliException e) {
11182       {
11183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11184       };
11185     } catch (...) {
11186       {
11187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11188       };
11189     }
11190   }
11191
11192   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11193   return jresult;
11194 }
11195
11196
11197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11198   void * jresult ;
11199   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11200   Dali::Quaternion *arg2 = 0 ;
11201   Dali::Quaternion result;
11202
11203   arg1 = (Dali::Quaternion *)jarg1;
11204   arg2 = (Dali::Quaternion *)jarg2;
11205   if (!arg2) {
11206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11207     return 0;
11208   }
11209   {
11210     try {
11211       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11212     } catch (std::out_of_range& e) {
11213       {
11214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11215       };
11216     } catch (std::exception& e) {
11217       {
11218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11219       };
11220     } catch (Dali::DaliException e) {
11221       {
11222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11223       };
11224     } catch (...) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11227       };
11228     }
11229   }
11230
11231   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11232   return jresult;
11233 }
11234
11235
11236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11237   void * jresult ;
11238   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11239   float arg2 ;
11240   Dali::Quaternion result;
11241
11242   arg1 = (Dali::Quaternion *)jarg1;
11243   arg2 = (float)jarg2;
11244   {
11245     try {
11246       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11254       };
11255     } catch (Dali::DaliException e) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11258       };
11259     } catch (...) {
11260       {
11261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11262       };
11263     }
11264   }
11265
11266   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11267   return jresult;
11268 }
11269
11270
11271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11272   void * jresult ;
11273   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11274   float arg2 ;
11275   Dali::Quaternion result;
11276
11277   arg1 = (Dali::Quaternion *)jarg1;
11278   arg2 = (float)jarg2;
11279   {
11280     try {
11281       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11282     } catch (std::out_of_range& e) {
11283       {
11284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11285       };
11286     } catch (std::exception& e) {
11287       {
11288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11289       };
11290     } catch (Dali::DaliException e) {
11291       {
11292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11293       };
11294     } catch (...) {
11295       {
11296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11297       };
11298     }
11299   }
11300
11301   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11302   return jresult;
11303 }
11304
11305
11306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11307   void * jresult ;
11308   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11309   Dali::Quaternion result;
11310
11311   arg1 = (Dali::Quaternion *)jarg1;
11312   {
11313     try {
11314       result = ((Dali::Quaternion const *)arg1)->operator -();
11315     } catch (std::out_of_range& e) {
11316       {
11317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11318       };
11319     } catch (std::exception& e) {
11320       {
11321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11322       };
11323     } catch (Dali::DaliException e) {
11324       {
11325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11326       };
11327     } catch (...) {
11328       {
11329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11330       };
11331     }
11332   }
11333
11334   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11335   return jresult;
11336 }
11337
11338
11339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11340   void * jresult ;
11341   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11342   Dali::Quaternion *arg2 = 0 ;
11343   Dali::Quaternion *result = 0 ;
11344
11345   arg1 = (Dali::Quaternion *)jarg1;
11346   arg2 = (Dali::Quaternion *)jarg2;
11347   if (!arg2) {
11348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11349     return 0;
11350   }
11351   {
11352     try {
11353       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11354     } catch (std::out_of_range& e) {
11355       {
11356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11357       };
11358     } catch (std::exception& e) {
11359       {
11360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11361       };
11362     } catch (Dali::DaliException e) {
11363       {
11364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11365       };
11366     } catch (...) {
11367       {
11368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11369       };
11370     }
11371   }
11372
11373   jresult = (void *)result;
11374   return jresult;
11375 }
11376
11377
11378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11379   void * jresult ;
11380   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11381   Dali::Quaternion *arg2 = 0 ;
11382   Dali::Quaternion *result = 0 ;
11383
11384   arg1 = (Dali::Quaternion *)jarg1;
11385   arg2 = (Dali::Quaternion *)jarg2;
11386   if (!arg2) {
11387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11388     return 0;
11389   }
11390   {
11391     try {
11392       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11393     } catch (std::out_of_range& e) {
11394       {
11395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11396       };
11397     } catch (std::exception& e) {
11398       {
11399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11400       };
11401     } catch (Dali::DaliException e) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11404       };
11405     } catch (...) {
11406       {
11407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11408       };
11409     }
11410   }
11411
11412   jresult = (void *)result;
11413   return jresult;
11414 }
11415
11416
11417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11418   void * jresult ;
11419   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11420   Dali::Quaternion *arg2 = 0 ;
11421   Dali::Quaternion *result = 0 ;
11422
11423   arg1 = (Dali::Quaternion *)jarg1;
11424   arg2 = (Dali::Quaternion *)jarg2;
11425   if (!arg2) {
11426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11427     return 0;
11428   }
11429   {
11430     try {
11431       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
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 (Dali::DaliException e) {
11441       {
11442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11443       };
11444     } catch (...) {
11445       {
11446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11447       };
11448     }
11449   }
11450
11451   jresult = (void *)result;
11452   return jresult;
11453 }
11454
11455
11456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11457   void * jresult ;
11458   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11459   float arg2 ;
11460   Dali::Quaternion *result = 0 ;
11461
11462   arg1 = (Dali::Quaternion *)jarg1;
11463   arg2 = (float)jarg2;
11464   {
11465     try {
11466       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11467     } catch (std::out_of_range& e) {
11468       {
11469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11470       };
11471     } catch (std::exception& e) {
11472       {
11473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11474       };
11475     } catch (Dali::DaliException e) {
11476       {
11477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11478       };
11479     } catch (...) {
11480       {
11481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11482       };
11483     }
11484   }
11485
11486   jresult = (void *)result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11492   void * jresult ;
11493   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11494   float arg2 ;
11495   Dali::Quaternion *result = 0 ;
11496
11497   arg1 = (Dali::Quaternion *)jarg1;
11498   arg2 = (float)jarg2;
11499   {
11500     try {
11501       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11502     } catch (std::out_of_range& e) {
11503       {
11504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11505       };
11506     } catch (std::exception& e) {
11507       {
11508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11509       };
11510     } catch (Dali::DaliException e) {
11511       {
11512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11517       };
11518     }
11519   }
11520
11521   jresult = (void *)result;
11522   return jresult;
11523 }
11524
11525
11526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11527   unsigned int jresult ;
11528   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11529   Dali::Quaternion *arg2 = 0 ;
11530   bool result;
11531
11532   arg1 = (Dali::Quaternion *)jarg1;
11533   arg2 = (Dali::Quaternion *)jarg2;
11534   if (!arg2) {
11535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11536     return 0;
11537   }
11538   {
11539     try {
11540       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11541     } catch (std::out_of_range& e) {
11542       {
11543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11544       };
11545     } catch (std::exception& e) {
11546       {
11547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11548       };
11549     } catch (Dali::DaliException e) {
11550       {
11551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11552       };
11553     } catch (...) {
11554       {
11555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11556       };
11557     }
11558   }
11559
11560   jresult = result;
11561   return jresult;
11562 }
11563
11564
11565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11566   unsigned int jresult ;
11567   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11568   Dali::Quaternion *arg2 = 0 ;
11569   bool result;
11570
11571   arg1 = (Dali::Quaternion *)jarg1;
11572   arg2 = (Dali::Quaternion *)jarg2;
11573   if (!arg2) {
11574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11575     return 0;
11576   }
11577   {
11578     try {
11579       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11580     } catch (std::out_of_range& e) {
11581       {
11582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11583       };
11584     } catch (std::exception& e) {
11585       {
11586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11587       };
11588     } catch (Dali::DaliException e) {
11589       {
11590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11591       };
11592     } catch (...) {
11593       {
11594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11595       };
11596     }
11597   }
11598
11599   jresult = result;
11600   return jresult;
11601 }
11602
11603
11604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11605   float jresult ;
11606   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11607   float result;
11608
11609   arg1 = (Dali::Quaternion *)jarg1;
11610   {
11611     try {
11612       result = (float)((Dali::Quaternion const *)arg1)->Length();
11613     } catch (std::out_of_range& e) {
11614       {
11615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11616       };
11617     } catch (std::exception& e) {
11618       {
11619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11620       };
11621     } catch (Dali::DaliException e) {
11622       {
11623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11624       };
11625     } catch (...) {
11626       {
11627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11628       };
11629     }
11630   }
11631
11632   jresult = result;
11633   return jresult;
11634 }
11635
11636
11637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11638   float jresult ;
11639   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11640   float result;
11641
11642   arg1 = (Dali::Quaternion *)jarg1;
11643   {
11644     try {
11645       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11646     } catch (std::out_of_range& e) {
11647       {
11648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11649       };
11650     } catch (std::exception& e) {
11651       {
11652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11653       };
11654     } catch (Dali::DaliException e) {
11655       {
11656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11657       };
11658     } catch (...) {
11659       {
11660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11661       };
11662     }
11663   }
11664
11665   jresult = result;
11666   return jresult;
11667 }
11668
11669
11670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11671   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11672
11673   arg1 = (Dali::Quaternion *)jarg1;
11674   {
11675     try {
11676       (arg1)->Normalize();
11677     } catch (std::out_of_range& e) {
11678       {
11679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11680       };
11681     } catch (std::exception& e) {
11682       {
11683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11684       };
11685     } catch (Dali::DaliException e) {
11686       {
11687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11688       };
11689     } catch (...) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11692       };
11693     }
11694   }
11695
11696 }
11697
11698
11699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11700   void * jresult ;
11701   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11702   Dali::Quaternion result;
11703
11704   arg1 = (Dali::Quaternion *)jarg1;
11705   {
11706     try {
11707       result = ((Dali::Quaternion const *)arg1)->Normalized();
11708     } catch (std::out_of_range& e) {
11709       {
11710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11711       };
11712     } catch (std::exception& e) {
11713       {
11714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11715       };
11716     } catch (Dali::DaliException e) {
11717       {
11718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11719       };
11720     } catch (...) {
11721       {
11722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11723       };
11724     }
11725   }
11726
11727   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11728   return jresult;
11729 }
11730
11731
11732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11733   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11734
11735   arg1 = (Dali::Quaternion *)jarg1;
11736   {
11737     try {
11738       (arg1)->Conjugate();
11739     } catch (std::out_of_range& e) {
11740       {
11741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11742       };
11743     } catch (std::exception& e) {
11744       {
11745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11746       };
11747     } catch (Dali::DaliException e) {
11748       {
11749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11750       };
11751     } catch (...) {
11752       {
11753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11754       };
11755     }
11756   }
11757
11758 }
11759
11760
11761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11762   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11763
11764   arg1 = (Dali::Quaternion *)jarg1;
11765   {
11766     try {
11767       (arg1)->Invert();
11768     } catch (std::out_of_range& e) {
11769       {
11770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11771       };
11772     } catch (std::exception& e) {
11773       {
11774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11775       };
11776     } catch (Dali::DaliException e) {
11777       {
11778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11779       };
11780     } catch (...) {
11781       {
11782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11783       };
11784     }
11785   }
11786
11787 }
11788
11789
11790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11791   void * jresult ;
11792   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11793   Dali::Quaternion result;
11794
11795   arg1 = (Dali::Quaternion *)jarg1;
11796   {
11797     try {
11798       result = ((Dali::Quaternion const *)arg1)->Log();
11799     } catch (std::out_of_range& e) {
11800       {
11801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11802       };
11803     } catch (std::exception& e) {
11804       {
11805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11806       };
11807     } catch (Dali::DaliException e) {
11808       {
11809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11810       };
11811     } catch (...) {
11812       {
11813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11814       };
11815     }
11816   }
11817
11818   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11819   return jresult;
11820 }
11821
11822
11823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11824   void * jresult ;
11825   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11826   Dali::Quaternion result;
11827
11828   arg1 = (Dali::Quaternion *)jarg1;
11829   {
11830     try {
11831       result = ((Dali::Quaternion const *)arg1)->Exp();
11832     } catch (std::out_of_range& e) {
11833       {
11834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11835       };
11836     } catch (std::exception& e) {
11837       {
11838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11839       };
11840     } catch (Dali::DaliException e) {
11841       {
11842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11843       };
11844     } catch (...) {
11845       {
11846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11847       };
11848     }
11849   }
11850
11851   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11852   return jresult;
11853 }
11854
11855
11856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11857   float jresult ;
11858   Dali::Quaternion *arg1 = 0 ;
11859   Dali::Quaternion *arg2 = 0 ;
11860   float result;
11861
11862   arg1 = (Dali::Quaternion *)jarg1;
11863   if (!arg1) {
11864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11865     return 0;
11866   }
11867   arg2 = (Dali::Quaternion *)jarg2;
11868   if (!arg2) {
11869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11870     return 0;
11871   }
11872   {
11873     try {
11874       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11875     } catch (std::out_of_range& e) {
11876       {
11877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (std::exception& e) {
11880       {
11881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11882       };
11883     } catch (Dali::DaliException e) {
11884       {
11885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11886       };
11887     } catch (...) {
11888       {
11889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11890       };
11891     }
11892   }
11893
11894   jresult = result;
11895   return jresult;
11896 }
11897
11898
11899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11900   void * jresult ;
11901   Dali::Quaternion *arg1 = 0 ;
11902   Dali::Quaternion *arg2 = 0 ;
11903   float arg3 ;
11904   Dali::Quaternion result;
11905
11906   arg1 = (Dali::Quaternion *)jarg1;
11907   if (!arg1) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11909     return 0;
11910   }
11911   arg2 = (Dali::Quaternion *)jarg2;
11912   if (!arg2) {
11913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11914     return 0;
11915   }
11916   arg3 = (float)jarg3;
11917   {
11918     try {
11919       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (Dali::DaliException e) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11931       };
11932     } catch (...) {
11933       {
11934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11935       };
11936     }
11937   }
11938
11939   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11940   return jresult;
11941 }
11942
11943
11944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11945   void * jresult ;
11946   Dali::Quaternion *arg1 = 0 ;
11947   Dali::Quaternion *arg2 = 0 ;
11948   float arg3 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (float)jarg3;
11962   {
11963     try {
11964       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (Dali::DaliException e) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983
11984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11990   void * jresult ;
11991   Dali::Quaternion *arg1 = 0 ;
11992   Dali::Quaternion *arg2 = 0 ;
11993   float arg3 ;
11994   Dali::Quaternion result;
11995
11996   arg1 = (Dali::Quaternion *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg2 = (Dali::Quaternion *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12004     return 0;
12005   }
12006   arg3 = (float)jarg3;
12007   {
12008     try {
12009       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12010     } catch (std::out_of_range& e) {
12011       {
12012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12013       };
12014     } catch (std::exception& e) {
12015       {
12016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (Dali::DaliException e) {
12019       {
12020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028
12029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12035   void * jresult ;
12036   Dali::Quaternion *arg1 = 0 ;
12037   Dali::Quaternion *arg2 = 0 ;
12038   Dali::Quaternion *arg3 = 0 ;
12039   Dali::Quaternion *arg4 = 0 ;
12040   float arg5 ;
12041   Dali::Quaternion result;
12042
12043   arg1 = (Dali::Quaternion *)jarg1;
12044   if (!arg1) {
12045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12046     return 0;
12047   }
12048   arg2 = (Dali::Quaternion *)jarg2;
12049   if (!arg2) {
12050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12051     return 0;
12052   }
12053   arg3 = (Dali::Quaternion *)jarg3;
12054   if (!arg3) {
12055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12056     return 0;
12057   }
12058   arg4 = (Dali::Quaternion *)jarg4;
12059   if (!arg4) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12061     return 0;
12062   }
12063   arg5 = (float)jarg5;
12064   {
12065     try {
12066       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12067     } catch (std::out_of_range& e) {
12068       {
12069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12070       };
12071     } catch (std::exception& e) {
12072       {
12073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12074       };
12075     } catch (Dali::DaliException e) {
12076       {
12077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12078       };
12079     } catch (...) {
12080       {
12081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12082       };
12083     }
12084   }
12085
12086   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12087   return jresult;
12088 }
12089
12090
12091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12092   float jresult ;
12093   Dali::Quaternion *arg1 = 0 ;
12094   Dali::Quaternion *arg2 = 0 ;
12095   float result;
12096
12097   arg1 = (Dali::Quaternion *)jarg1;
12098   if (!arg1) {
12099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12100     return 0;
12101   }
12102   arg2 = (Dali::Quaternion *)jarg2;
12103   if (!arg2) {
12104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12105     return 0;
12106   }
12107   {
12108     try {
12109       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12110     } catch (std::out_of_range& e) {
12111       {
12112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12113       };
12114     } catch (std::exception& e) {
12115       {
12116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (Dali::DaliException e) {
12119       {
12120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128
12129   jresult = result;
12130   return jresult;
12131 }
12132
12133
12134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12135   void * jresult ;
12136   Dali::Matrix *result = 0 ;
12137
12138   {
12139     try {
12140       result = (Dali::Matrix *)new Dali::Matrix();
12141     } catch (std::out_of_range& e) {
12142       {
12143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12144       };
12145     } catch (std::exception& e) {
12146       {
12147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12148       };
12149     } catch (Dali::DaliException e) {
12150       {
12151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12152       };
12153     } catch (...) {
12154       {
12155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12156       };
12157     }
12158   }
12159
12160   jresult = (void *)result;
12161   return jresult;
12162 }
12163
12164
12165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12166   void * jresult ;
12167   bool arg1 ;
12168   Dali::Matrix *result = 0 ;
12169
12170   arg1 = jarg1 ? true : false;
12171   {
12172     try {
12173       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12174     } catch (std::out_of_range& e) {
12175       {
12176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12177       };
12178     } catch (std::exception& e) {
12179       {
12180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12181       };
12182     } catch (Dali::DaliException e) {
12183       {
12184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12185       };
12186     } catch (...) {
12187       {
12188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12189       };
12190     }
12191   }
12192
12193   jresult = (void *)result;
12194   return jresult;
12195 }
12196
12197
12198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12199   void * jresult ;
12200   float *arg1 = (float *) 0 ;
12201   Dali::Matrix *result = 0 ;
12202
12203   arg1 = jarg1;
12204   {
12205     try {
12206       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12207     } catch (std::out_of_range& e) {
12208       {
12209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12210       };
12211     } catch (std::exception& e) {
12212       {
12213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12214       };
12215     } catch (Dali::DaliException e) {
12216       {
12217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12218       };
12219     } catch (...) {
12220       {
12221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12222       };
12223     }
12224   }
12225
12226   jresult = (void *)result;
12227
12228
12229   return jresult;
12230 }
12231
12232
12233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12234   void * jresult ;
12235   Dali::Quaternion *arg1 = 0 ;
12236   Dali::Matrix *result = 0 ;
12237
12238   arg1 = (Dali::Quaternion *)jarg1;
12239   if (!arg1) {
12240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12241     return 0;
12242   }
12243   {
12244     try {
12245       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion 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 (Dali::DaliException e) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12257       };
12258     } catch (...) {
12259       {
12260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12261       };
12262     }
12263   }
12264
12265   jresult = (void *)result;
12266   return jresult;
12267 }
12268
12269
12270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12271   void * jresult ;
12272   Dali::Matrix *arg1 = 0 ;
12273   Dali::Matrix *result = 0 ;
12274
12275   arg1 = (Dali::Matrix *)jarg1;
12276   if (!arg1) {
12277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12278     return 0;
12279   }
12280   {
12281     try {
12282       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12283     } catch (std::out_of_range& e) {
12284       {
12285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12286       };
12287     } catch (std::exception& e) {
12288       {
12289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12290       };
12291     } catch (Dali::DaliException e) {
12292       {
12293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12294       };
12295     } catch (...) {
12296       {
12297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12298       };
12299     }
12300   }
12301
12302   jresult = (void *)result;
12303   return jresult;
12304 }
12305
12306
12307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12308   void * jresult ;
12309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12310   Dali::Matrix *arg2 = 0 ;
12311   Dali::Matrix *result = 0 ;
12312
12313   arg1 = (Dali::Matrix *)jarg1;
12314   arg2 = (Dali::Matrix *)jarg2;
12315   if (!arg2) {
12316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12317     return 0;
12318   }
12319   {
12320     try {
12321       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
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 (Dali::DaliException e) {
12331       {
12332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12333       };
12334     } catch (...) {
12335       {
12336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12337       };
12338     }
12339   }
12340
12341   jresult = (void *)result;
12342   return jresult;
12343 }
12344
12345
12346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12347   void * jresult ;
12348   Dali::Matrix *result = 0 ;
12349
12350   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12351   jresult = (void *)result;
12352   return jresult;
12353 }
12354
12355
12356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358
12359   arg1 = (Dali::Matrix *)jarg1;
12360   {
12361     try {
12362       (arg1)->SetIdentity();
12363     } catch (std::out_of_range& e) {
12364       {
12365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12366       };
12367     } catch (std::exception& e) {
12368       {
12369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12370       };
12371     } catch (Dali::DaliException e) {
12372       {
12373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12374       };
12375     } catch (...) {
12376       {
12377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12378       };
12379     }
12380   }
12381
12382 }
12383
12384
12385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12386   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12387   Dali::Vector3 *arg2 = 0 ;
12388
12389   arg1 = (Dali::Matrix *)jarg1;
12390   arg2 = (Dali::Vector3 *)jarg2;
12391   if (!arg2) {
12392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12393     return ;
12394   }
12395   {
12396     try {
12397       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12398     } catch (std::out_of_range& e) {
12399       {
12400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12401       };
12402     } catch (std::exception& e) {
12403       {
12404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12405       };
12406     } catch (Dali::DaliException e) {
12407       {
12408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12413       };
12414     }
12415   }
12416
12417 }
12418
12419
12420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12421   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12422   Dali::Matrix *arg2 = 0 ;
12423
12424   arg1 = (Dali::Matrix *)jarg1;
12425   arg2 = (Dali::Matrix *)jarg2;
12426   if (!arg2) {
12427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12428     return ;
12429   }
12430   {
12431     try {
12432       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12433     } catch (std::out_of_range& e) {
12434       {
12435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12436       };
12437     } catch (std::exception& e) {
12438       {
12439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12440       };
12441     } catch (Dali::DaliException e) {
12442       {
12443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12444       };
12445     } catch (...) {
12446       {
12447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12448       };
12449     }
12450   }
12451
12452 }
12453
12454
12455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12456   unsigned int jresult ;
12457   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12458   bool result;
12459
12460   arg1 = (Dali::Matrix *)jarg1;
12461   {
12462     try {
12463       result = (bool)(arg1)->Invert();
12464     } catch (std::out_of_range& e) {
12465       {
12466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12467       };
12468     } catch (std::exception& e) {
12469       {
12470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12471       };
12472     } catch (Dali::DaliException e) {
12473       {
12474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12475       };
12476     } catch (...) {
12477       {
12478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12479       };
12480     }
12481   }
12482
12483   jresult = result;
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12489   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12490
12491   arg1 = (Dali::Matrix *)jarg1;
12492   {
12493     try {
12494       (arg1)->Transpose();
12495     } catch (std::out_of_range& e) {
12496       {
12497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12498       };
12499     } catch (std::exception& e) {
12500       {
12501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12502       };
12503     } catch (Dali::DaliException e) {
12504       {
12505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12506       };
12507     } catch (...) {
12508       {
12509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12510       };
12511     }
12512   }
12513
12514 }
12515
12516
12517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12518   void * jresult ;
12519   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12520   Dali::Vector3 result;
12521
12522   arg1 = (Dali::Matrix *)jarg1;
12523   {
12524     try {
12525       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12526     } catch (std::out_of_range& e) {
12527       {
12528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12529       };
12530     } catch (std::exception& e) {
12531       {
12532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12533       };
12534     } catch (Dali::DaliException e) {
12535       {
12536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12537       };
12538     } catch (...) {
12539       {
12540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12541       };
12542     }
12543   }
12544
12545   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12546   return jresult;
12547 }
12548
12549
12550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12551   void * jresult ;
12552   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12553   Dali::Vector3 result;
12554
12555   arg1 = (Dali::Matrix *)jarg1;
12556   {
12557     try {
12558       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12559     } catch (std::out_of_range& e) {
12560       {
12561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12562       };
12563     } catch (std::exception& e) {
12564       {
12565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12566       };
12567     } catch (Dali::DaliException e) {
12568       {
12569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12570       };
12571     } catch (...) {
12572       {
12573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12574       };
12575     }
12576   }
12577
12578   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12579   return jresult;
12580 }
12581
12582
12583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12584   void * jresult ;
12585   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12586   Dali::Vector3 result;
12587
12588   arg1 = (Dali::Matrix *)jarg1;
12589   {
12590     try {
12591       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12592     } catch (std::out_of_range& e) {
12593       {
12594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12595       };
12596     } catch (std::exception& e) {
12597       {
12598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12599       };
12600     } catch (Dali::DaliException e) {
12601       {
12602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12603       };
12604     } catch (...) {
12605       {
12606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12607       };
12608     }
12609   }
12610
12611   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12612   return jresult;
12613 }
12614
12615
12616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12617   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12618   Dali::Vector3 *arg2 = 0 ;
12619
12620   arg1 = (Dali::Matrix *)jarg1;
12621   arg2 = (Dali::Vector3 *)jarg2;
12622   if (!arg2) {
12623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12624     return ;
12625   }
12626   {
12627     try {
12628       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12629     } catch (std::out_of_range& e) {
12630       {
12631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12632       };
12633     } catch (std::exception& e) {
12634       {
12635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12636       };
12637     } catch (Dali::DaliException e) {
12638       {
12639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12640       };
12641     } catch (...) {
12642       {
12643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12644       };
12645     }
12646   }
12647
12648 }
12649
12650
12651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12653   Dali::Vector3 *arg2 = 0 ;
12654
12655   arg1 = (Dali::Matrix *)jarg1;
12656   arg2 = (Dali::Vector3 *)jarg2;
12657   if (!arg2) {
12658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12659     return ;
12660   }
12661   {
12662     try {
12663       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12664     } catch (std::out_of_range& e) {
12665       {
12666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12667       };
12668     } catch (std::exception& e) {
12669       {
12670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12671       };
12672     } catch (Dali::DaliException e) {
12673       {
12674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12675       };
12676     } catch (...) {
12677       {
12678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12679       };
12680     }
12681   }
12682
12683 }
12684
12685
12686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12687   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12688   Dali::Vector3 *arg2 = 0 ;
12689
12690   arg1 = (Dali::Matrix *)jarg1;
12691   arg2 = (Dali::Vector3 *)jarg2;
12692   if (!arg2) {
12693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12694     return ;
12695   }
12696   {
12697     try {
12698       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12699     } catch (std::out_of_range& e) {
12700       {
12701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12702       };
12703     } catch (std::exception& e) {
12704       {
12705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12706       };
12707     } catch (Dali::DaliException e) {
12708       {
12709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12710       };
12711     } catch (...) {
12712       {
12713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12714       };
12715     }
12716   }
12717
12718 }
12719
12720
12721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12722   void * jresult ;
12723   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12724   Dali::Vector4 *result = 0 ;
12725
12726   arg1 = (Dali::Matrix *)jarg1;
12727   {
12728     try {
12729       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12730     } catch (std::out_of_range& e) {
12731       {
12732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (std::exception& e) {
12735       {
12736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12737       };
12738     } catch (Dali::DaliException e) {
12739       {
12740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12741       };
12742     } catch (...) {
12743       {
12744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12745       };
12746     }
12747   }
12748
12749   jresult = (void *)result;
12750   return jresult;
12751 }
12752
12753
12754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12755   void * jresult ;
12756   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12757   Dali::Vector3 *result = 0 ;
12758
12759   arg1 = (Dali::Matrix *)jarg1;
12760   {
12761     try {
12762       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12763     } catch (std::out_of_range& e) {
12764       {
12765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12766       };
12767     } catch (std::exception& e) {
12768       {
12769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12770       };
12771     } catch (Dali::DaliException e) {
12772       {
12773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12774       };
12775     } catch (...) {
12776       {
12777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12778       };
12779     }
12780   }
12781
12782   jresult = (void *)result;
12783   return jresult;
12784 }
12785
12786
12787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12788   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12789   Dali::Vector4 *arg2 = 0 ;
12790
12791   arg1 = (Dali::Matrix *)jarg1;
12792   arg2 = (Dali::Vector4 *)jarg2;
12793   if (!arg2) {
12794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12795     return ;
12796   }
12797   {
12798     try {
12799       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12800     } catch (std::out_of_range& e) {
12801       {
12802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12803       };
12804     } catch (std::exception& e) {
12805       {
12806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12807       };
12808     } catch (Dali::DaliException e) {
12809       {
12810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12811       };
12812     } catch (...) {
12813       {
12814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12815       };
12816     }
12817   }
12818
12819 }
12820
12821
12822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12823   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12824   Dali::Vector3 *arg2 = 0 ;
12825
12826   arg1 = (Dali::Matrix *)jarg1;
12827   arg2 = (Dali::Vector3 *)jarg2;
12828   if (!arg2) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12830     return ;
12831   }
12832   {
12833     try {
12834       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12842       };
12843     } catch (Dali::DaliException e) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12846       };
12847     } catch (...) {
12848       {
12849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12850       };
12851     }
12852   }
12853
12854 }
12855
12856
12857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12858   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12859
12860   arg1 = (Dali::Matrix *)jarg1;
12861   {
12862     try {
12863       (arg1)->OrthoNormalize();
12864     } catch (std::out_of_range& e) {
12865       {
12866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12867       };
12868     } catch (std::exception& e) {
12869       {
12870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12871       };
12872     } catch (Dali::DaliException e) {
12873       {
12874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12875       };
12876     } catch (...) {
12877       {
12878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12879       };
12880     }
12881   }
12882
12883 }
12884
12885
12886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12887   void * jresult ;
12888   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12889   float *result = 0 ;
12890
12891   arg1 = (Dali::Matrix *)jarg1;
12892   {
12893     try {
12894       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12895     } catch (std::out_of_range& e) {
12896       {
12897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12898       };
12899     } catch (std::exception& e) {
12900       {
12901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12902       };
12903     } catch (Dali::DaliException e) {
12904       {
12905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12906       };
12907     } catch (...) {
12908       {
12909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12910       };
12911     }
12912   }
12913
12914   jresult = (void *)result;
12915   return jresult;
12916 }
12917
12918
12919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12920   Dali::Matrix *arg1 = 0 ;
12921   Dali::Matrix *arg2 = 0 ;
12922   Dali::Matrix *arg3 = 0 ;
12923
12924   arg1 = (Dali::Matrix *)jarg1;
12925   if (!arg1) {
12926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12927     return ;
12928   }
12929   arg2 = (Dali::Matrix *)jarg2;
12930   if (!arg2) {
12931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12932     return ;
12933   }
12934   arg3 = (Dali::Matrix *)jarg3;
12935   if (!arg3) {
12936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12937     return ;
12938   }
12939   {
12940     try {
12941       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12942     } catch (std::out_of_range& e) {
12943       {
12944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12945       };
12946     } catch (std::exception& e) {
12947       {
12948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12949       };
12950     } catch (Dali::DaliException e) {
12951       {
12952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12953       };
12954     } catch (...) {
12955       {
12956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12957       };
12958     }
12959   }
12960
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12965   Dali::Matrix *arg1 = 0 ;
12966   Dali::Matrix *arg2 = 0 ;
12967   Dali::Quaternion *arg3 = 0 ;
12968
12969   arg1 = (Dali::Matrix *)jarg1;
12970   if (!arg1) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12972     return ;
12973   }
12974   arg2 = (Dali::Matrix *)jarg2;
12975   if (!arg2) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   arg3 = (Dali::Quaternion *)jarg3;
12980   if (!arg3) {
12981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12982     return ;
12983   }
12984   {
12985     try {
12986       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12994       };
12995     } catch (Dali::DaliException e) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12998       };
12999     } catch (...) {
13000       {
13001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13002       };
13003     }
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13010   void * jresult ;
13011   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13012   Dali::Vector4 *arg2 = 0 ;
13013   Dali::Vector4 result;
13014
13015   arg1 = (Dali::Matrix *)jarg1;
13016   arg2 = (Dali::Vector4 *)jarg2;
13017   if (!arg2) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13019     return 0;
13020   }
13021   {
13022     try {
13023       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13024     } catch (std::out_of_range& e) {
13025       {
13026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13027       };
13028     } catch (std::exception& e) {
13029       {
13030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13031       };
13032     } catch (Dali::DaliException e) {
13033       {
13034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13035       };
13036     } catch (...) {
13037       {
13038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13039       };
13040     }
13041   }
13042
13043   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13044   return jresult;
13045 }
13046
13047
13048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13049   unsigned int jresult ;
13050   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13051   Dali::Matrix *arg2 = 0 ;
13052   bool result;
13053
13054   arg1 = (Dali::Matrix *)jarg1;
13055   arg2 = (Dali::Matrix *)jarg2;
13056   if (!arg2) {
13057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13058     return 0;
13059   }
13060   {
13061     try {
13062       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13063     } catch (std::out_of_range& e) {
13064       {
13065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13066       };
13067     } catch (std::exception& e) {
13068       {
13069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13070       };
13071     } catch (Dali::DaliException e) {
13072       {
13073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13074       };
13075     } catch (...) {
13076       {
13077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13078       };
13079     }
13080   }
13081
13082   jresult = result;
13083   return jresult;
13084 }
13085
13086
13087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13088   unsigned int jresult ;
13089   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13090   Dali::Matrix *arg2 = 0 ;
13091   bool result;
13092
13093   arg1 = (Dali::Matrix *)jarg1;
13094   arg2 = (Dali::Matrix *)jarg2;
13095   if (!arg2) {
13096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13097     return 0;
13098   }
13099   {
13100     try {
13101       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13102     } catch (std::out_of_range& e) {
13103       {
13104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13105       };
13106     } catch (std::exception& e) {
13107       {
13108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13109       };
13110     } catch (Dali::DaliException e) {
13111       {
13112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13113       };
13114     } catch (...) {
13115       {
13116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13117       };
13118     }
13119   }
13120
13121   jresult = result;
13122   return jresult;
13123 }
13124
13125
13126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13127   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13128   Dali::Vector3 *arg2 = 0 ;
13129   Dali::Quaternion *arg3 = 0 ;
13130   Dali::Vector3 *arg4 = 0 ;
13131
13132   arg1 = (Dali::Matrix *)jarg1;
13133   arg2 = (Dali::Vector3 *)jarg2;
13134   if (!arg2) {
13135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13136     return ;
13137   }
13138   arg3 = (Dali::Quaternion *)jarg3;
13139   if (!arg3) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13141     return ;
13142   }
13143   arg4 = (Dali::Vector3 *)jarg4;
13144   if (!arg4) {
13145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13146     return ;
13147   }
13148   {
13149     try {
13150       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13151     } catch (std::out_of_range& e) {
13152       {
13153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13154       };
13155     } catch (std::exception& e) {
13156       {
13157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13158       };
13159     } catch (Dali::DaliException e) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13162       };
13163     } catch (...) {
13164       {
13165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13166       };
13167     }
13168   }
13169
13170 }
13171
13172
13173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13174   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13175   Dali::Vector3 *arg2 = 0 ;
13176   Dali::Quaternion *arg3 = 0 ;
13177   Dali::Vector3 *arg4 = 0 ;
13178
13179   arg1 = (Dali::Matrix *)jarg1;
13180   arg2 = (Dali::Vector3 *)jarg2;
13181   if (!arg2) {
13182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13183     return ;
13184   }
13185   arg3 = (Dali::Quaternion *)jarg3;
13186   if (!arg3) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13188     return ;
13189   }
13190   arg4 = (Dali::Vector3 *)jarg4;
13191   if (!arg4) {
13192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13193     return ;
13194   }
13195   {
13196     try {
13197       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13198     } catch (std::out_of_range& e) {
13199       {
13200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13201       };
13202     } catch (std::exception& e) {
13203       {
13204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13205       };
13206     } catch (Dali::DaliException e) {
13207       {
13208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13209       };
13210     } catch (...) {
13211       {
13212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13213       };
13214     }
13215   }
13216
13217 }
13218
13219
13220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13221   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13222   Dali::Vector3 *arg2 = 0 ;
13223   Dali::Vector3 *arg3 = 0 ;
13224   Dali::Vector3 *arg4 = 0 ;
13225   Dali::Vector3 *arg5 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Vector3 *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   arg5 = (Dali::Vector3 *)jarg5;
13244   if (!arg5) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13246     return ;
13247   }
13248   {
13249     try {
13250       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13251     } catch (std::out_of_range& e) {
13252       {
13253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13254       };
13255     } catch (std::exception& e) {
13256       {
13257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13258       };
13259     } catch (Dali::DaliException e) {
13260       {
13261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13262       };
13263     } catch (...) {
13264       {
13265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13266       };
13267     }
13268   }
13269
13270 }
13271
13272
13273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13274   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13275   Dali::Vector3 *arg2 = 0 ;
13276   Dali::Quaternion *arg3 = 0 ;
13277   Dali::Vector3 *arg4 = 0 ;
13278
13279   arg1 = (Dali::Matrix *)jarg1;
13280   arg2 = (Dali::Vector3 *)jarg2;
13281   if (!arg2) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13283     return ;
13284   }
13285   arg3 = (Dali::Quaternion *)jarg3;
13286   if (!arg3) {
13287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13288     return ;
13289   }
13290   arg4 = (Dali::Vector3 *)jarg4;
13291   if (!arg4) {
13292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13293     return ;
13294   }
13295   {
13296     try {
13297       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13298     } catch (std::out_of_range& e) {
13299       {
13300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13301       };
13302     } catch (std::exception& e) {
13303       {
13304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13305       };
13306     } catch (Dali::DaliException e) {
13307       {
13308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13309       };
13310     } catch (...) {
13311       {
13312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13313       };
13314     }
13315   }
13316
13317 }
13318
13319
13320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13321   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13322
13323   arg1 = (Dali::Matrix *)jarg1;
13324   {
13325     try {
13326       delete arg1;
13327     } catch (std::out_of_range& e) {
13328       {
13329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13330       };
13331     } catch (std::exception& e) {
13332       {
13333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13334       };
13335     } catch (Dali::DaliException e) {
13336       {
13337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13338       };
13339     } catch (...) {
13340       {
13341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13342       };
13343     }
13344   }
13345
13346 }
13347
13348
13349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13350   void * jresult ;
13351   Dali::Matrix3 *result = 0 ;
13352
13353   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13354   jresult = (void *)result;
13355   return jresult;
13356 }
13357
13358
13359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13360   void * jresult ;
13361   Dali::Matrix3 *result = 0 ;
13362
13363   {
13364     try {
13365       result = (Dali::Matrix3 *)new Dali::Matrix3();
13366     } catch (std::out_of_range& e) {
13367       {
13368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13369       };
13370     } catch (std::exception& e) {
13371       {
13372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13373       };
13374     } catch (Dali::DaliException e) {
13375       {
13376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13377       };
13378     } catch (...) {
13379       {
13380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13381       };
13382     }
13383   }
13384
13385   jresult = (void *)result;
13386   return jresult;
13387 }
13388
13389
13390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13391   void * jresult ;
13392   Dali::Matrix3 *arg1 = 0 ;
13393   Dali::Matrix3 *result = 0 ;
13394
13395   arg1 = (Dali::Matrix3 *)jarg1;
13396   if (!arg1) {
13397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13398     return 0;
13399   }
13400   {
13401     try {
13402       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13403     } catch (std::out_of_range& e) {
13404       {
13405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13406       };
13407     } catch (std::exception& e) {
13408       {
13409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13410       };
13411     } catch (Dali::DaliException e) {
13412       {
13413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13414       };
13415     } catch (...) {
13416       {
13417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13418       };
13419     }
13420   }
13421
13422   jresult = (void *)result;
13423   return jresult;
13424 }
13425
13426
13427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13428   void * jresult ;
13429   Dali::Matrix *arg1 = 0 ;
13430   Dali::Matrix3 *result = 0 ;
13431
13432   arg1 = (Dali::Matrix *)jarg1;
13433   if (!arg1) {
13434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13435     return 0;
13436   }
13437   {
13438     try {
13439       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13440     } catch (std::out_of_range& e) {
13441       {
13442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13443       };
13444     } catch (std::exception& e) {
13445       {
13446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13447       };
13448     } catch (Dali::DaliException e) {
13449       {
13450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13451       };
13452     } catch (...) {
13453       {
13454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13455       };
13456     }
13457   }
13458
13459   jresult = (void *)result;
13460   return jresult;
13461 }
13462
13463
13464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13465   void * jresult ;
13466   float arg1 ;
13467   float arg2 ;
13468   float arg3 ;
13469   float arg4 ;
13470   float arg5 ;
13471   float arg6 ;
13472   float arg7 ;
13473   float arg8 ;
13474   float arg9 ;
13475   Dali::Matrix3 *result = 0 ;
13476
13477   arg1 = (float)jarg1;
13478   arg2 = (float)jarg2;
13479   arg3 = (float)jarg3;
13480   arg4 = (float)jarg4;
13481   arg5 = (float)jarg5;
13482   arg6 = (float)jarg6;
13483   arg7 = (float)jarg7;
13484   arg8 = (float)jarg8;
13485   arg9 = (float)jarg9;
13486   {
13487     try {
13488       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13489     } catch (std::out_of_range& e) {
13490       {
13491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13492       };
13493     } catch (std::exception& e) {
13494       {
13495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13496       };
13497     } catch (Dali::DaliException e) {
13498       {
13499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13500       };
13501     } catch (...) {
13502       {
13503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13504       };
13505     }
13506   }
13507
13508   jresult = (void *)result;
13509   return jresult;
13510 }
13511
13512
13513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13514   void * jresult ;
13515   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13516   Dali::Matrix3 *arg2 = 0 ;
13517   Dali::Matrix3 *result = 0 ;
13518
13519   arg1 = (Dali::Matrix3 *)jarg1;
13520   arg2 = (Dali::Matrix3 *)jarg2;
13521   if (!arg2) {
13522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13523     return 0;
13524   }
13525   {
13526     try {
13527       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13528     } catch (std::out_of_range& e) {
13529       {
13530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13531       };
13532     } catch (std::exception& e) {
13533       {
13534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13535       };
13536     } catch (Dali::DaliException e) {
13537       {
13538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13539       };
13540     } catch (...) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13543       };
13544     }
13545   }
13546
13547   jresult = (void *)result;
13548   return jresult;
13549 }
13550
13551
13552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13553   void * jresult ;
13554   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13555   Dali::Matrix *arg2 = 0 ;
13556   Dali::Matrix3 *result = 0 ;
13557
13558   arg1 = (Dali::Matrix3 *)jarg1;
13559   arg2 = (Dali::Matrix *)jarg2;
13560   if (!arg2) {
13561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13562     return 0;
13563   }
13564   {
13565     try {
13566       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13567     } catch (std::out_of_range& e) {
13568       {
13569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13570       };
13571     } catch (std::exception& e) {
13572       {
13573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13574       };
13575     } catch (Dali::DaliException e) {
13576       {
13577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13578       };
13579     } catch (...) {
13580       {
13581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13582       };
13583     }
13584   }
13585
13586   jresult = (void *)result;
13587   return jresult;
13588 }
13589
13590
13591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13592   unsigned int jresult ;
13593   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13594   Dali::Matrix3 *arg2 = 0 ;
13595   bool result;
13596
13597   arg1 = (Dali::Matrix3 *)jarg1;
13598   arg2 = (Dali::Matrix3 *)jarg2;
13599   if (!arg2) {
13600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13601     return 0;
13602   }
13603   {
13604     try {
13605       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13606     } catch (std::out_of_range& e) {
13607       {
13608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13609       };
13610     } catch (std::exception& e) {
13611       {
13612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13613       };
13614     } catch (Dali::DaliException e) {
13615       {
13616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13617       };
13618     } catch (...) {
13619       {
13620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13621       };
13622     }
13623   }
13624
13625   jresult = result;
13626   return jresult;
13627 }
13628
13629
13630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13631   unsigned int jresult ;
13632   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13633   Dali::Matrix3 *arg2 = 0 ;
13634   bool result;
13635
13636   arg1 = (Dali::Matrix3 *)jarg1;
13637   arg2 = (Dali::Matrix3 *)jarg2;
13638   if (!arg2) {
13639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13640     return 0;
13641   }
13642   {
13643     try {
13644       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13645     } catch (std::out_of_range& e) {
13646       {
13647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13648       };
13649     } catch (std::exception& e) {
13650       {
13651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13652       };
13653     } catch (Dali::DaliException e) {
13654       {
13655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13656       };
13657     } catch (...) {
13658       {
13659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13660       };
13661     }
13662   }
13663
13664   jresult = result;
13665   return jresult;
13666 }
13667
13668
13669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13670   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13671
13672   arg1 = (Dali::Matrix3 *)jarg1;
13673   {
13674     try {
13675       delete arg1;
13676     } catch (std::out_of_range& e) {
13677       {
13678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13679       };
13680     } catch (std::exception& e) {
13681       {
13682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13683       };
13684     } catch (Dali::DaliException e) {
13685       {
13686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13687       };
13688     } catch (...) {
13689       {
13690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13691       };
13692     }
13693   }
13694
13695 }
13696
13697
13698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13699   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13700
13701   arg1 = (Dali::Matrix3 *)jarg1;
13702   {
13703     try {
13704       (arg1)->SetIdentity();
13705     } catch (std::out_of_range& e) {
13706       {
13707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13708       };
13709     } catch (std::exception& e) {
13710       {
13711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13712       };
13713     } catch (Dali::DaliException e) {
13714       {
13715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13716       };
13717     } catch (...) {
13718       {
13719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13720       };
13721     }
13722   }
13723
13724 }
13725
13726
13727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13728   void * jresult ;
13729   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13730   float *result = 0 ;
13731
13732   arg1 = (Dali::Matrix3 *)jarg1;
13733   {
13734     try {
13735       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13736     } catch (std::out_of_range& e) {
13737       {
13738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13739       };
13740     } catch (std::exception& e) {
13741       {
13742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13743       };
13744     } catch (Dali::DaliException e) {
13745       {
13746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13747       };
13748     } catch (...) {
13749       {
13750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13751       };
13752     }
13753   }
13754
13755   jresult = (void *)result;
13756   return jresult;
13757 }
13758
13759
13760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13761   unsigned int jresult ;
13762   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13763   bool result;
13764
13765   arg1 = (Dali::Matrix3 *)jarg1;
13766   {
13767     try {
13768       result = (bool)(arg1)->Invert();
13769     } catch (std::out_of_range& e) {
13770       {
13771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13772       };
13773     } catch (std::exception& e) {
13774       {
13775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13776       };
13777     } catch (Dali::DaliException e) {
13778       {
13779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13780       };
13781     } catch (...) {
13782       {
13783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13784       };
13785     }
13786   }
13787
13788   jresult = result;
13789   return jresult;
13790 }
13791
13792
13793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13794   unsigned int jresult ;
13795   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13796   bool result;
13797
13798   arg1 = (Dali::Matrix3 *)jarg1;
13799   {
13800     try {
13801       result = (bool)(arg1)->Transpose();
13802     } catch (std::out_of_range& e) {
13803       {
13804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13805       };
13806     } catch (std::exception& e) {
13807       {
13808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13809       };
13810     } catch (Dali::DaliException e) {
13811       {
13812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13813       };
13814     } catch (...) {
13815       {
13816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13817       };
13818     }
13819   }
13820
13821   jresult = result;
13822   return jresult;
13823 }
13824
13825
13826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13827   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13828   float arg2 ;
13829
13830   arg1 = (Dali::Matrix3 *)jarg1;
13831   arg2 = (float)jarg2;
13832   {
13833     try {
13834       (arg1)->Scale(arg2);
13835     } catch (std::out_of_range& e) {
13836       {
13837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13838       };
13839     } catch (std::exception& e) {
13840       {
13841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13842       };
13843     } catch (Dali::DaliException e) {
13844       {
13845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13846       };
13847     } catch (...) {
13848       {
13849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13850       };
13851     }
13852   }
13853
13854 }
13855
13856
13857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13858   float jresult ;
13859   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13860   float result;
13861
13862   arg1 = (Dali::Matrix3 *)jarg1;
13863   {
13864     try {
13865       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13866     } catch (std::out_of_range& e) {
13867       {
13868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13869       };
13870     } catch (std::exception& e) {
13871       {
13872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13873       };
13874     } catch (Dali::DaliException e) {
13875       {
13876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13877       };
13878     } catch (...) {
13879       {
13880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13881       };
13882     }
13883   }
13884
13885   jresult = result;
13886   return jresult;
13887 }
13888
13889
13890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13891   unsigned int jresult ;
13892   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13893   bool result;
13894
13895   arg1 = (Dali::Matrix3 *)jarg1;
13896   {
13897     try {
13898       result = (bool)(arg1)->ScaledInverseTranspose();
13899     } catch (std::out_of_range& e) {
13900       {
13901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13902       };
13903     } catch (std::exception& e) {
13904       {
13905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13906       };
13907     } catch (Dali::DaliException e) {
13908       {
13909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13910       };
13911     } catch (...) {
13912       {
13913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13914       };
13915     }
13916   }
13917
13918   jresult = result;
13919   return jresult;
13920 }
13921
13922
13923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13924   Dali::Matrix3 *arg1 = 0 ;
13925   Dali::Matrix3 *arg2 = 0 ;
13926   Dali::Matrix3 *arg3 = 0 ;
13927
13928   arg1 = (Dali::Matrix3 *)jarg1;
13929   if (!arg1) {
13930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13931     return ;
13932   }
13933   arg2 = (Dali::Matrix3 *)jarg2;
13934   if (!arg2) {
13935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13936     return ;
13937   }
13938   arg3 = (Dali::Matrix3 *)jarg3;
13939   if (!arg3) {
13940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13941     return ;
13942   }
13943   {
13944     try {
13945       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13946     } catch (std::out_of_range& e) {
13947       {
13948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13949       };
13950     } catch (std::exception& e) {
13951       {
13952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13953       };
13954     } catch (Dali::DaliException e) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13957       };
13958     } catch (...) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13961       };
13962     }
13963   }
13964
13965 }
13966
13967
13968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13969   float jresult ;
13970   float arg1 ;
13971   float arg2 ;
13972   float result;
13973
13974   arg1 = (float)jarg1;
13975   arg2 = (float)jarg2;
13976   {
13977     try {
13978       result = (float)Dali::Random::Range(arg1,arg2);
13979     } catch (std::out_of_range& e) {
13980       {
13981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13982       };
13983     } catch (std::exception& e) {
13984       {
13985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13986       };
13987     } catch (Dali::DaliException e) {
13988       {
13989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13990       };
13991     } catch (...) {
13992       {
13993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13994       };
13995     }
13996   }
13997
13998   jresult = result;
13999   return jresult;
14000 }
14001
14002
14003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14004   void * jresult ;
14005   Dali::Vector4 result;
14006
14007   {
14008     try {
14009       result = Dali::Random::Axis();
14010     } catch (std::out_of_range& e) {
14011       {
14012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14013       };
14014     } catch (std::exception& e) {
14015       {
14016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14017       };
14018     } catch (Dali::DaliException e) {
14019       {
14020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14021       };
14022     } catch (...) {
14023       {
14024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14025       };
14026     }
14027   }
14028
14029   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14030   return jresult;
14031 }
14032
14033
14034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14035   void * jresult ;
14036   Dali::AngleAxis *result = 0 ;
14037
14038   {
14039     try {
14040       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14041     } catch (std::out_of_range& e) {
14042       {
14043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14044       };
14045     } catch (std::exception& e) {
14046       {
14047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14048       };
14049     } catch (Dali::DaliException e) {
14050       {
14051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14052       };
14053     } catch (...) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14056       };
14057     }
14058   }
14059
14060   jresult = (void *)result;
14061   return jresult;
14062 }
14063
14064
14065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14066   void * jresult ;
14067   Dali::Radian arg1 ;
14068   Dali::Vector3 *arg2 = 0 ;
14069   Dali::Radian *argp1 ;
14070   Dali::AngleAxis *result = 0 ;
14071
14072   argp1 = (Dali::Radian *)jarg1;
14073   if (!argp1) {
14074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14075     return 0;
14076   }
14077   arg1 = *argp1;
14078   arg2 = (Dali::Vector3 *)jarg2;
14079   if (!arg2) {
14080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14081     return 0;
14082   }
14083   {
14084     try {
14085       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14086     } catch (std::out_of_range& e) {
14087       {
14088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (std::exception& e) {
14091       {
14092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14093       };
14094     } catch (Dali::DaliException e) {
14095       {
14096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14101       };
14102     }
14103   }
14104
14105   jresult = (void *)result;
14106   return jresult;
14107 }
14108
14109
14110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14111   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14112   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14113
14114   arg1 = (Dali::AngleAxis *)jarg1;
14115   arg2 = (Dali::Radian *)jarg2;
14116   if (arg1) (arg1)->angle = *arg2;
14117 }
14118
14119
14120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14121   void * jresult ;
14122   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14123   Dali::Radian *result = 0 ;
14124
14125   arg1 = (Dali::AngleAxis *)jarg1;
14126   result = (Dali::Radian *)& ((arg1)->angle);
14127   jresult = (void *)result;
14128   return jresult;
14129 }
14130
14131
14132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14133   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14134   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14135
14136   arg1 = (Dali::AngleAxis *)jarg1;
14137   arg2 = (Dali::Vector3 *)jarg2;
14138   if (arg1) (arg1)->axis = *arg2;
14139 }
14140
14141
14142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14143   void * jresult ;
14144   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14145   Dali::Vector3 *result = 0 ;
14146
14147   arg1 = (Dali::AngleAxis *)jarg1;
14148   result = (Dali::Vector3 *)& ((arg1)->axis);
14149   jresult = (void *)result;
14150   return jresult;
14151 }
14152
14153
14154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14155   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14156
14157   arg1 = (Dali::AngleAxis *)jarg1;
14158   {
14159     try {
14160       delete arg1;
14161     } catch (std::out_of_range& e) {
14162       {
14163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14164       };
14165     } catch (std::exception& e) {
14166       {
14167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14168       };
14169     } catch (Dali::DaliException e) {
14170       {
14171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14172       };
14173     } catch (...) {
14174       {
14175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14176       };
14177     }
14178   }
14179
14180 }
14181
14182
14183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14184   unsigned int jresult ;
14185   Dali::AngleAxis *arg1 = 0 ;
14186   Dali::AngleAxis *arg2 = 0 ;
14187   bool result;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   if (!arg1) {
14191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14192     return 0;
14193   }
14194   arg2 = (Dali::AngleAxis *)jarg2;
14195   if (!arg2) {
14196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14197     return 0;
14198   }
14199   {
14200     try {
14201       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14202     } catch (std::out_of_range& e) {
14203       {
14204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14205       };
14206     } catch (std::exception& e) {
14207       {
14208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14209       };
14210     } catch (Dali::DaliException e) {
14211       {
14212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14213       };
14214     } catch (...) {
14215       {
14216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14217       };
14218     }
14219   }
14220
14221   jresult = result;
14222   return jresult;
14223 }
14224
14225
14226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14227   unsigned int jresult ;
14228   unsigned int arg1 ;
14229   unsigned int result;
14230
14231   arg1 = (unsigned int)jarg1;
14232   {
14233     try {
14234       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14235     } catch (std::out_of_range& e) {
14236       {
14237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14238       };
14239     } catch (std::exception& e) {
14240       {
14241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14242       };
14243     } catch (Dali::DaliException e) {
14244       {
14245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14246       };
14247     } catch (...) {
14248       {
14249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14250       };
14251     }
14252   }
14253
14254   jresult = result;
14255   return jresult;
14256 }
14257
14258
14259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14260   unsigned int jresult ;
14261   unsigned int arg1 ;
14262   bool result;
14263
14264   arg1 = (unsigned int)jarg1;
14265   {
14266     try {
14267       result = (bool)Dali::IsPowerOfTwo(arg1);
14268     } catch (std::out_of_range& e) {
14269       {
14270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14271       };
14272     } catch (std::exception& e) {
14273       {
14274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14275       };
14276     } catch (Dali::DaliException e) {
14277       {
14278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14279       };
14280     } catch (...) {
14281       {
14282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14283       };
14284     }
14285   }
14286
14287   jresult = result;
14288   return jresult;
14289 }
14290
14291
14292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14293   float jresult ;
14294   float arg1 ;
14295   float arg2 ;
14296   float result;
14297
14298   arg1 = (float)jarg1;
14299   arg2 = (float)jarg2;
14300   {
14301     try {
14302       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14303     } catch (std::out_of_range& e) {
14304       {
14305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14306       };
14307     } catch (std::exception& e) {
14308       {
14309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14310       };
14311     } catch (Dali::DaliException e) {
14312       {
14313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14314       };
14315     } catch (...) {
14316       {
14317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14318       };
14319     }
14320   }
14321
14322   jresult = result;
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14328   unsigned int jresult ;
14329   float arg1 ;
14330   bool result;
14331
14332   arg1 = (float)jarg1;
14333   {
14334     try {
14335       result = (bool)Dali::EqualsZero(arg1);
14336     } catch (std::out_of_range& e) {
14337       {
14338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14339       };
14340     } catch (std::exception& e) {
14341       {
14342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14343       };
14344     } catch (Dali::DaliException e) {
14345       {
14346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14347       };
14348     } catch (...) {
14349       {
14350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14351       };
14352     }
14353   }
14354
14355   jresult = result;
14356   return jresult;
14357 }
14358
14359
14360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14361   unsigned int jresult ;
14362   float arg1 ;
14363   float arg2 ;
14364   bool result;
14365
14366   arg1 = (float)jarg1;
14367   arg2 = (float)jarg2;
14368   {
14369     try {
14370       result = (bool)Dali::Equals(arg1,arg2);
14371     } catch (std::out_of_range& e) {
14372       {
14373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14374       };
14375     } catch (std::exception& e) {
14376       {
14377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14378       };
14379     } catch (Dali::DaliException e) {
14380       {
14381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14382       };
14383     } catch (...) {
14384       {
14385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14386       };
14387     }
14388   }
14389
14390   jresult = result;
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14396   unsigned int jresult ;
14397   float arg1 ;
14398   float arg2 ;
14399   float arg3 ;
14400   bool result;
14401
14402   arg1 = (float)jarg1;
14403   arg2 = (float)jarg2;
14404   arg3 = (float)jarg3;
14405   {
14406     try {
14407       result = (bool)Dali::Equals(arg1,arg2,arg3);
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 (Dali::DaliException e) {
14417       {
14418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14419       };
14420     } catch (...) {
14421       {
14422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14423       };
14424     }
14425   }
14426
14427   jresult = result;
14428   return jresult;
14429 }
14430
14431
14432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14433   float jresult ;
14434   float arg1 ;
14435   int arg2 ;
14436   float result;
14437
14438   arg1 = (float)jarg1;
14439   arg2 = (int)jarg2;
14440   {
14441     try {
14442       result = (float)Dali::Round(arg1,arg2);
14443     } catch (std::out_of_range& e) {
14444       {
14445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14446       };
14447     } catch (std::exception& e) {
14448       {
14449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14450       };
14451     } catch (Dali::DaliException e) {
14452       {
14453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14454       };
14455     } catch (...) {
14456       {
14457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14458       };
14459     }
14460   }
14461
14462   jresult = result;
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14468   float jresult ;
14469   float arg1 ;
14470   float arg2 ;
14471   float arg3 ;
14472   float result;
14473
14474   arg1 = (float)jarg1;
14475   arg2 = (float)jarg2;
14476   arg3 = (float)jarg3;
14477   {
14478     try {
14479       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14480     } catch (std::out_of_range& e) {
14481       {
14482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14483       };
14484     } catch (std::exception& e) {
14485       {
14486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14487       };
14488     } catch (Dali::DaliException e) {
14489       {
14490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14491       };
14492     } catch (...) {
14493       {
14494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14495       };
14496     }
14497   }
14498
14499   jresult = result;
14500   return jresult;
14501 }
14502
14503
14504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14505   float jresult ;
14506   float arg1 ;
14507   float arg2 ;
14508   float arg3 ;
14509   float arg4 ;
14510   float result;
14511
14512   arg1 = (float)jarg1;
14513   arg2 = (float)jarg2;
14514   arg3 = (float)jarg3;
14515   arg4 = (float)jarg4;
14516   {
14517     try {
14518       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14519     } catch (std::out_of_range& e) {
14520       {
14521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14522       };
14523     } catch (std::exception& e) {
14524       {
14525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14526       };
14527     } catch (Dali::DaliException e) {
14528       {
14529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14530       };
14531     } catch (...) {
14532       {
14533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14534       };
14535     }
14536   }
14537
14538   jresult = result;
14539   return jresult;
14540 }
14541
14542
14543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14544   int jresult ;
14545   int result;
14546
14547   result = (int)(int)Dali::Property::INVALID_INDEX;
14548   jresult = result;
14549   return jresult;
14550 }
14551
14552
14553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14554   int jresult ;
14555   int result;
14556
14557   result = (int)(int)Dali::Property::INVALID_KEY;
14558   jresult = result;
14559   return jresult;
14560 }
14561
14562
14563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14564   int jresult ;
14565   int result;
14566
14567   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14568   jresult = result;
14569   return jresult;
14570 }
14571
14572
14573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14574   void * jresult ;
14575   Dali::Handle *arg1 = 0 ;
14576   Dali::Property::Index arg2 ;
14577   Dali::Property *result = 0 ;
14578
14579   arg1 = (Dali::Handle *)jarg1;
14580   if (!arg1) {
14581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14582     return 0;
14583   }
14584   arg2 = (Dali::Property::Index)jarg2;
14585   {
14586     try {
14587       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14588     } catch (std::out_of_range& e) {
14589       {
14590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14591       };
14592     } catch (std::exception& e) {
14593       {
14594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14595       };
14596     } catch (Dali::DaliException e) {
14597       {
14598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14599       };
14600     } catch (...) {
14601       {
14602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14603       };
14604     }
14605   }
14606
14607   jresult = (void *)result;
14608   return jresult;
14609 }
14610
14611
14612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14613   void * jresult ;
14614   Dali::Handle *arg1 = 0 ;
14615   Dali::Property::Index arg2 ;
14616   int arg3 ;
14617   Dali::Property *result = 0 ;
14618
14619   arg1 = (Dali::Handle *)jarg1;
14620   if (!arg1) {
14621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14622     return 0;
14623   }
14624   arg2 = (Dali::Property::Index)jarg2;
14625   arg3 = (int)jarg3;
14626   {
14627     try {
14628       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14629     } catch (std::out_of_range& e) {
14630       {
14631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14632       };
14633     } catch (std::exception& e) {
14634       {
14635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (Dali::DaliException e) {
14638       {
14639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14640       };
14641     } catch (...) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14644       };
14645     }
14646   }
14647
14648   jresult = (void *)result;
14649   return jresult;
14650 }
14651
14652
14653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14654   void * jresult ;
14655   Dali::Handle *arg1 = 0 ;
14656   std::string *arg2 = 0 ;
14657   Dali::Property *result = 0 ;
14658
14659   arg1 = (Dali::Handle *)jarg1;
14660   if (!arg1) {
14661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14662     return 0;
14663   }
14664   if (!jarg2) {
14665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14666     return 0;
14667   }
14668   std::string arg2_str(jarg2);
14669   arg2 = &arg2_str;
14670   {
14671     try {
14672       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14673     } catch (std::out_of_range& e) {
14674       {
14675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14676       };
14677     } catch (std::exception& e) {
14678       {
14679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (Dali::DaliException e) {
14682       {
14683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14684       };
14685     } catch (...) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14688       };
14689     }
14690   }
14691
14692   jresult = (void *)result;
14693
14694   //argout typemap for const std::string&
14695
14696   return jresult;
14697 }
14698
14699
14700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14701   void * jresult ;
14702   Dali::Handle *arg1 = 0 ;
14703   std::string *arg2 = 0 ;
14704   int arg3 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   arg3 = (int)jarg3;
14719   {
14720     try {
14721       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14722     } catch (std::out_of_range& e) {
14723       {
14724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (std::exception& e) {
14727       {
14728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14729       };
14730     } catch (Dali::DaliException e) {
14731       {
14732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14733       };
14734     } catch (...) {
14735       {
14736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14737       };
14738     }
14739   }
14740
14741   jresult = (void *)result;
14742
14743   //argout typemap for const std::string&
14744
14745   return jresult;
14746 }
14747
14748
14749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14750   Dali::Property *arg1 = (Dali::Property *) 0 ;
14751
14752   arg1 = (Dali::Property *)jarg1;
14753   {
14754     try {
14755       delete arg1;
14756     } catch (std::out_of_range& e) {
14757       {
14758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14759       };
14760     } catch (std::exception& e) {
14761       {
14762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14763       };
14764     } catch (Dali::DaliException e) {
14765       {
14766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14767       };
14768     } catch (...) {
14769       {
14770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14771       };
14772     }
14773   }
14774
14775 }
14776
14777
14778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14779   Dali::Property *arg1 = (Dali::Property *) 0 ;
14780   Dali::Handle *arg2 = 0 ;
14781
14782   arg1 = (Dali::Property *)jarg1;
14783   arg2 = (Dali::Handle *)jarg2;
14784   if (!arg2) {
14785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14786     return ;
14787   }
14788   if (arg1) (arg1)->object = *arg2;
14789 }
14790
14791
14792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14793   void * jresult ;
14794   Dali::Property *arg1 = (Dali::Property *) 0 ;
14795   Dali::Handle *result = 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14799   jresult = (void *)result;
14800   return jresult;
14801 }
14802
14803
14804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14805   Dali::Property *arg1 = (Dali::Property *) 0 ;
14806   Dali::Property::Index arg2 ;
14807
14808   arg1 = (Dali::Property *)jarg1;
14809   arg2 = (Dali::Property::Index)jarg2;
14810   if (arg1) (arg1)->propertyIndex = arg2;
14811 }
14812
14813
14814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14815   int jresult ;
14816   Dali::Property *arg1 = (Dali::Property *) 0 ;
14817   Dali::Property::Index result;
14818
14819   arg1 = (Dali::Property *)jarg1;
14820   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14821   jresult = result;
14822   return jresult;
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   int arg2 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (int)jarg2;
14832   if (arg1) (arg1)->componentIndex = arg2;
14833 }
14834
14835
14836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14837   int jresult ;
14838   Dali::Property *arg1 = (Dali::Property *) 0 ;
14839   int result;
14840
14841   arg1 = (Dali::Property *)jarg1;
14842   result = (int) ((arg1)->componentIndex);
14843   jresult = result;
14844   return jresult;
14845 }
14846
14847
14848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14849   void * jresult ;
14850   Dali::Property::Array *result = 0 ;
14851
14852   {
14853     try {
14854       result = (Dali::Property::Array *)new Dali::Property::Array();
14855     } catch (std::out_of_range& e) {
14856       {
14857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14858       };
14859     } catch (std::exception& e) {
14860       {
14861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14862       };
14863     } catch (Dali::DaliException e) {
14864       {
14865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14866       };
14867     } catch (...) {
14868       {
14869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14870       };
14871     }
14872   }
14873
14874   jresult = (void *)result;
14875   return jresult;
14876 }
14877
14878
14879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14880   void * jresult ;
14881   Dali::Property::Array *arg1 = 0 ;
14882   Dali::Property::Array *result = 0 ;
14883
14884   arg1 = (Dali::Property::Array *)jarg1;
14885   if (!arg1) {
14886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14887     return 0;
14888   }
14889   {
14890     try {
14891       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14892     } catch (std::out_of_range& e) {
14893       {
14894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14895       };
14896     } catch (std::exception& e) {
14897       {
14898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14899       };
14900     } catch (Dali::DaliException e) {
14901       {
14902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14903       };
14904     } catch (...) {
14905       {
14906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14907       };
14908     }
14909   }
14910
14911   jresult = (void *)result;
14912   return jresult;
14913 }
14914
14915
14916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14917   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14918
14919   arg1 = (Dali::Property::Array *)jarg1;
14920   {
14921     try {
14922       delete arg1;
14923     } catch (std::out_of_range& e) {
14924       {
14925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14926       };
14927     } catch (std::exception& e) {
14928       {
14929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14930       };
14931     } catch (Dali::DaliException e) {
14932       {
14933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14934       };
14935     } catch (...) {
14936       {
14937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14938       };
14939     }
14940   }
14941
14942 }
14943
14944
14945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14946   unsigned long jresult ;
14947   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14948   Dali::Property::Array::SizeType result;
14949
14950   arg1 = (Dali::Property::Array *)jarg1;
14951   {
14952     try {
14953       result = ((Dali::Property::Array const *)arg1)->Size();
14954     } catch (std::out_of_range& e) {
14955       {
14956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14957       };
14958     } catch (std::exception& e) {
14959       {
14960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14961       };
14962     } catch (Dali::DaliException e) {
14963       {
14964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14965       };
14966     } catch (...) {
14967       {
14968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14969       };
14970     }
14971   }
14972
14973   jresult = (unsigned long)result;
14974   return jresult;
14975 }
14976
14977
14978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14979   unsigned long jresult ;
14980   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14981   Dali::Property::Array::SizeType result;
14982
14983   arg1 = (Dali::Property::Array *)jarg1;
14984   {
14985     try {
14986       result = ((Dali::Property::Array const *)arg1)->Count();
14987     } catch (std::out_of_range& e) {
14988       {
14989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14990       };
14991     } catch (std::exception& e) {
14992       {
14993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14994       };
14995     } catch (Dali::DaliException e) {
14996       {
14997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14998       };
14999     } catch (...) {
15000       {
15001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15002       };
15003     }
15004   }
15005
15006   jresult = (unsigned long)result;
15007   return jresult;
15008 }
15009
15010
15011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15012   unsigned int jresult ;
15013   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15014   bool result;
15015
15016   arg1 = (Dali::Property::Array *)jarg1;
15017   {
15018     try {
15019       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15020     } catch (std::out_of_range& e) {
15021       {
15022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15023       };
15024     } catch (std::exception& e) {
15025       {
15026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15027       };
15028     } catch (Dali::DaliException e) {
15029       {
15030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15031       };
15032     } catch (...) {
15033       {
15034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15035       };
15036     }
15037   }
15038
15039   jresult = result;
15040   return jresult;
15041 }
15042
15043
15044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15045   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15046
15047   arg1 = (Dali::Property::Array *)jarg1;
15048   {
15049     try {
15050       (arg1)->Clear();
15051     } catch (std::out_of_range& e) {
15052       {
15053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15054       };
15055     } catch (std::exception& e) {
15056       {
15057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15058       };
15059     } catch (Dali::DaliException e) {
15060       {
15061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15062       };
15063     } catch (...) {
15064       {
15065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15066       };
15067     }
15068   }
15069
15070 }
15071
15072
15073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15074   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15075   Dali::Property::Array::SizeType arg2 ;
15076
15077   arg1 = (Dali::Property::Array *)jarg1;
15078   arg2 = (Dali::Property::Array::SizeType)jarg2;
15079   {
15080     try {
15081       (arg1)->Reserve(arg2);
15082     } catch (std::out_of_range& e) {
15083       {
15084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15085       };
15086     } catch (std::exception& e) {
15087       {
15088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15089       };
15090     } catch (Dali::DaliException e) {
15091       {
15092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15093       };
15094     } catch (...) {
15095       {
15096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15097       };
15098     }
15099   }
15100
15101 }
15102
15103
15104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15105   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15106   Dali::Property::Array::SizeType arg2 ;
15107
15108   arg1 = (Dali::Property::Array *)jarg1;
15109   arg2 = (Dali::Property::Array::SizeType)jarg2;
15110   {
15111     try {
15112       (arg1)->Resize(arg2);
15113     } catch (std::out_of_range& e) {
15114       {
15115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15116       };
15117     } catch (std::exception& e) {
15118       {
15119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15120       };
15121     } catch (Dali::DaliException e) {
15122       {
15123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15124       };
15125     } catch (...) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15128       };
15129     }
15130   }
15131
15132 }
15133
15134
15135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15136   unsigned long jresult ;
15137   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15138   Dali::Property::Array::SizeType result;
15139
15140   arg1 = (Dali::Property::Array *)jarg1;
15141   {
15142     try {
15143       result = (arg1)->Capacity();
15144     } catch (std::out_of_range& e) {
15145       {
15146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15147       };
15148     } catch (std::exception& e) {
15149       {
15150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15151       };
15152     } catch (Dali::DaliException e) {
15153       {
15154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15155       };
15156     } catch (...) {
15157       {
15158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15159       };
15160     }
15161   }
15162
15163   jresult = (unsigned long)result;
15164   return jresult;
15165 }
15166
15167
15168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15169   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15170   Dali::Property::Value *arg2 = 0 ;
15171
15172   arg1 = (Dali::Property::Array *)jarg1;
15173   arg2 = (Dali::Property::Value *)jarg2;
15174   if (!arg2) {
15175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15176     return ;
15177   }
15178   {
15179     try {
15180       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15181     } catch (std::out_of_range& e) {
15182       {
15183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15184       };
15185     } catch (std::exception& e) {
15186       {
15187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15188       };
15189     } catch (Dali::DaliException e) {
15190       {
15191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15192       };
15193     } catch (...) {
15194       {
15195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15196       };
15197     }
15198   }
15199
15200 }
15201
15202
15203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15204   void * jresult ;
15205   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15206   Dali::Property::Value *arg2 = 0 ;
15207   Dali::Property::Array *result = 0 ;
15208
15209   arg1 = (Dali::Property::Array *)jarg1;
15210   arg2 = (Dali::Property::Value *)jarg2;
15211   if (!arg2) {
15212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15213     return 0;
15214   }
15215   {
15216     try {
15217       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15218     } catch (std::out_of_range& e) {
15219       {
15220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15221       };
15222     } catch (std::exception& e) {
15223       {
15224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15225       };
15226     } catch (Dali::DaliException e) {
15227       {
15228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15229       };
15230     } catch (...) {
15231       {
15232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15233       };
15234     }
15235   }
15236
15237   jresult = (void *)result;
15238   return jresult;
15239 }
15240
15241
15242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15243   void * jresult ;
15244   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15245   Dali::Property::Array::SizeType arg2 ;
15246   Dali::Property::Value *result = 0 ;
15247
15248   arg1 = (Dali::Property::Array *)jarg1;
15249   arg2 = (Dali::Property::Array::SizeType)jarg2;
15250   {
15251     try {
15252       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15253     } catch (std::out_of_range& e) {
15254       {
15255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15256       };
15257     } catch (std::exception& e) {
15258       {
15259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15260       };
15261     } catch (Dali::DaliException e) {
15262       {
15263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15264       };
15265     } catch (...) {
15266       {
15267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15268       };
15269     }
15270   }
15271
15272   jresult = (void *)result;
15273   return jresult;
15274 }
15275
15276
15277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15278   void * jresult ;
15279   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15280   Dali::Property::Array::SizeType arg2 ;
15281   Dali::Property::Value *result = 0 ;
15282
15283   arg1 = (Dali::Property::Array *)jarg1;
15284   arg2 = (Dali::Property::Array::SizeType)jarg2;
15285   {
15286     try {
15287       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15288     } catch (std::out_of_range& e) {
15289       {
15290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15291       };
15292     } catch (std::exception& e) {
15293       {
15294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (Dali::DaliException e) {
15297       {
15298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306
15307   jresult = (void *)result;
15308   return jresult;
15309 }
15310
15311
15312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15313   void * jresult ;
15314   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15315   Dali::Property::Array *arg2 = 0 ;
15316   Dali::Property::Array *result = 0 ;
15317
15318   arg1 = (Dali::Property::Array *)jarg1;
15319   arg2 = (Dali::Property::Array *)jarg2;
15320   if (!arg2) {
15321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15322     return 0;
15323   }
15324   {
15325     try {
15326       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15327     } catch (std::out_of_range& e) {
15328       {
15329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15330       };
15331     } catch (std::exception& e) {
15332       {
15333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15334       };
15335     } catch (Dali::DaliException e) {
15336       {
15337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15338       };
15339     } catch (...) {
15340       {
15341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15342       };
15343     }
15344   }
15345
15346   jresult = (void *)result;
15347   return jresult;
15348 }
15349
15350
15351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15352   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15353   enum Dali::Property::Key::Type arg2 ;
15354
15355   arg1 = (Dali::Property::Key *)jarg1;
15356   arg2 = (enum Dali::Property::Key::Type)jarg2;
15357   if (arg1) (arg1)->type = arg2;
15358 }
15359
15360
15361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15362   int jresult ;
15363   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15364   enum Dali::Property::Key::Type result;
15365
15366   arg1 = (Dali::Property::Key *)jarg1;
15367   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15368   jresult = (int)result;
15369   return jresult;
15370 }
15371
15372
15373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15374   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15375   Dali::Property::Index arg2 ;
15376
15377   arg1 = (Dali::Property::Key *)jarg1;
15378   arg2 = (Dali::Property::Index)jarg2;
15379   if (arg1) (arg1)->indexKey = arg2;
15380 }
15381
15382
15383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15384   int jresult ;
15385   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15386   Dali::Property::Index result;
15387
15388   arg1 = (Dali::Property::Key *)jarg1;
15389   result = (Dali::Property::Index) ((arg1)->indexKey);
15390   jresult = result;
15391   return jresult;
15392 }
15393
15394
15395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15396   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15397   std::string *arg2 = 0 ;
15398
15399   arg1 = (Dali::Property::Key *)jarg1;
15400   if (!jarg2) {
15401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15402     return ;
15403   }
15404   std::string arg2_str(jarg2);
15405   arg2 = &arg2_str;
15406   if (arg1) (arg1)->stringKey = *arg2;
15407
15408   //argout typemap for const std::string&
15409
15410 }
15411
15412
15413 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15414   char * jresult ;
15415   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15416   std::string *result = 0 ;
15417
15418   arg1 = (Dali::Property::Key *)jarg1;
15419   result = (std::string *) & ((arg1)->stringKey);
15420   jresult = SWIG_csharp_string_callback(result->c_str());
15421   return jresult;
15422 }
15423
15424
15425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15426   void * jresult ;
15427   std::string *arg1 = 0 ;
15428   Dali::Property::Key *result = 0 ;
15429
15430   if (!jarg1) {
15431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15432     return 0;
15433   }
15434   std::string arg1_str(jarg1);
15435   arg1 = &arg1_str;
15436   {
15437     try {
15438       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15439     } catch (std::out_of_range& e) {
15440       {
15441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15442       };
15443     } catch (std::exception& e) {
15444       {
15445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15446       };
15447     } catch (Dali::DaliException e) {
15448       {
15449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15450       };
15451     } catch (...) {
15452       {
15453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15454       };
15455     }
15456   }
15457
15458   jresult = (void *)result;
15459
15460   //argout typemap for const std::string&
15461
15462   return jresult;
15463 }
15464
15465
15466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15467   void * jresult ;
15468   Dali::Property::Index arg1 ;
15469   Dali::Property::Key *result = 0 ;
15470
15471   arg1 = (Dali::Property::Index)jarg1;
15472   {
15473     try {
15474       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15475     } catch (std::out_of_range& e) {
15476       {
15477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15478       };
15479     } catch (std::exception& e) {
15480       {
15481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (Dali::DaliException e) {
15484       {
15485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15486       };
15487     } catch (...) {
15488       {
15489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15490       };
15491     }
15492   }
15493
15494   jresult = (void *)result;
15495   return jresult;
15496 }
15497
15498
15499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15500   unsigned int jresult ;
15501   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15502   std::string *arg2 = 0 ;
15503   bool result;
15504
15505   arg1 = (Dali::Property::Key *)jarg1;
15506   if (!jarg2) {
15507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15508     return 0;
15509   }
15510   std::string arg2_str(jarg2);
15511   arg2 = &arg2_str;
15512   {
15513     try {
15514       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15515     } catch (std::out_of_range& e) {
15516       {
15517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15518       };
15519     } catch (std::exception& e) {
15520       {
15521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15522       };
15523     } catch (Dali::DaliException e) {
15524       {
15525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15526       };
15527     } catch (...) {
15528       {
15529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15530       };
15531     }
15532   }
15533
15534   jresult = result;
15535
15536   //argout typemap for const std::string&
15537
15538   return jresult;
15539 }
15540
15541
15542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15543   unsigned int jresult ;
15544   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15545   Dali::Property::Index arg2 ;
15546   bool result;
15547
15548   arg1 = (Dali::Property::Key *)jarg1;
15549   arg2 = (Dali::Property::Index)jarg2;
15550   {
15551     try {
15552       result = (bool)(arg1)->operator ==(arg2);
15553     } catch (std::out_of_range& e) {
15554       {
15555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15556       };
15557     } catch (std::exception& e) {
15558       {
15559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15560       };
15561     } catch (Dali::DaliException e) {
15562       {
15563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15564       };
15565     } catch (...) {
15566       {
15567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15568       };
15569     }
15570   }
15571
15572   jresult = result;
15573   return jresult;
15574 }
15575
15576
15577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15578   unsigned int jresult ;
15579   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15580   Dali::Property::Key *arg2 = 0 ;
15581   bool result;
15582
15583   arg1 = (Dali::Property::Key *)jarg1;
15584   arg2 = (Dali::Property::Key *)jarg2;
15585   if (!arg2) {
15586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15587     return 0;
15588   }
15589   {
15590     try {
15591       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15592     } catch (std::out_of_range& e) {
15593       {
15594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15595       };
15596     } catch (std::exception& e) {
15597       {
15598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15599       };
15600     } catch (Dali::DaliException e) {
15601       {
15602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15603       };
15604     } catch (...) {
15605       {
15606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15607       };
15608     }
15609   }
15610
15611   jresult = result;
15612   return jresult;
15613 }
15614
15615
15616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15617   unsigned int jresult ;
15618   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15619   std::string *arg2 = 0 ;
15620   bool result;
15621
15622   arg1 = (Dali::Property::Key *)jarg1;
15623   if (!jarg2) {
15624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15625     return 0;
15626   }
15627   std::string arg2_str(jarg2);
15628   arg2 = &arg2_str;
15629   {
15630     try {
15631       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15632     } catch (std::out_of_range& e) {
15633       {
15634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15635       };
15636     } catch (std::exception& e) {
15637       {
15638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15639       };
15640     } catch (Dali::DaliException e) {
15641       {
15642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15643       };
15644     } catch (...) {
15645       {
15646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15647       };
15648     }
15649   }
15650
15651   jresult = result;
15652
15653   //argout typemap for const std::string&
15654
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15660   unsigned int jresult ;
15661   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15662   Dali::Property::Index arg2 ;
15663   bool result;
15664
15665   arg1 = (Dali::Property::Key *)jarg1;
15666   arg2 = (Dali::Property::Index)jarg2;
15667   {
15668     try {
15669       result = (bool)(arg1)->operator !=(arg2);
15670     } catch (std::out_of_range& e) {
15671       {
15672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15673       };
15674     } catch (std::exception& e) {
15675       {
15676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (Dali::DaliException e) {
15679       {
15680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15681       };
15682     } catch (...) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15685       };
15686     }
15687   }
15688
15689   jresult = result;
15690   return jresult;
15691 }
15692
15693
15694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15695   unsigned int jresult ;
15696   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15697   Dali::Property::Key *arg2 = 0 ;
15698   bool result;
15699
15700   arg1 = (Dali::Property::Key *)jarg1;
15701   arg2 = (Dali::Property::Key *)jarg2;
15702   if (!arg2) {
15703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15704     return 0;
15705   }
15706   {
15707     try {
15708       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15709     } catch (std::out_of_range& e) {
15710       {
15711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (std::exception& e) {
15714       {
15715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (Dali::DaliException e) {
15718       {
15719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15720       };
15721     } catch (...) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15724       };
15725     }
15726   }
15727
15728   jresult = result;
15729   return jresult;
15730 }
15731
15732
15733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15734   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15735
15736   arg1 = (Dali::Property::Key *)jarg1;
15737   {
15738     try {
15739       delete arg1;
15740     } catch (std::out_of_range& e) {
15741       {
15742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15743       };
15744     } catch (std::exception& e) {
15745       {
15746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15747       };
15748     } catch (Dali::DaliException e) {
15749       {
15750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15751       };
15752     } catch (...) {
15753       {
15754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15755       };
15756     }
15757   }
15758
15759 }
15760
15761
15762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15763   void * jresult ;
15764   Dali::Property::Map *result = 0 ;
15765
15766   {
15767     try {
15768       result = (Dali::Property::Map *)new Dali::Property::Map();
15769     } catch (std::out_of_range& e) {
15770       {
15771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15772       };
15773     } catch (std::exception& e) {
15774       {
15775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15776       };
15777     } catch (Dali::DaliException e) {
15778       {
15779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15780       };
15781     } catch (...) {
15782       {
15783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15784       };
15785     }
15786   }
15787
15788   jresult = (void *)result;
15789   return jresult;
15790 }
15791
15792
15793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15794   void * jresult ;
15795   Dali::Property::Map *arg1 = 0 ;
15796   Dali::Property::Map *result = 0 ;
15797
15798   arg1 = (Dali::Property::Map *)jarg1;
15799   if (!arg1) {
15800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15801     return 0;
15802   }
15803   {
15804     try {
15805       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15806     } catch (std::out_of_range& e) {
15807       {
15808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15809       };
15810     } catch (std::exception& e) {
15811       {
15812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15813       };
15814     } catch (Dali::DaliException e) {
15815       {
15816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15817       };
15818     } catch (...) {
15819       {
15820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15821       };
15822     }
15823   }
15824
15825   jresult = (void *)result;
15826   return jresult;
15827 }
15828
15829
15830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15831   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15832
15833   arg1 = (Dali::Property::Map *)jarg1;
15834   {
15835     try {
15836       delete arg1;
15837     } catch (std::out_of_range& e) {
15838       {
15839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15840       };
15841     } catch (std::exception& e) {
15842       {
15843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15844       };
15845     } catch (Dali::DaliException e) {
15846       {
15847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15848       };
15849     } catch (...) {
15850       {
15851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15852       };
15853     }
15854   }
15855
15856 }
15857
15858
15859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15860   unsigned long jresult ;
15861   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15862   Dali::Property::Map::SizeType result;
15863
15864   arg1 = (Dali::Property::Map *)jarg1;
15865   {
15866     try {
15867       result = ((Dali::Property::Map const *)arg1)->Count();
15868     } catch (std::out_of_range& e) {
15869       {
15870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15871       };
15872     } catch (std::exception& e) {
15873       {
15874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15875       };
15876     } catch (Dali::DaliException e) {
15877       {
15878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15879       };
15880     } catch (...) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15883       };
15884     }
15885   }
15886
15887   jresult = (unsigned long)result;
15888   return jresult;
15889 }
15890
15891
15892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15893   unsigned int jresult ;
15894   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15895   bool result;
15896
15897   arg1 = (Dali::Property::Map *)jarg1;
15898   {
15899     try {
15900       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
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 (Dali::DaliException e) {
15910       {
15911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15912       };
15913     } catch (...) {
15914       {
15915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15916       };
15917     }
15918   }
15919
15920   jresult = result;
15921   return jresult;
15922 }
15923
15924
15925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15926   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15927   char *arg2 = (char *) 0 ;
15928   Dali::Property::Value *arg3 = 0 ;
15929
15930   arg1 = (Dali::Property::Map *)jarg1;
15931   arg2 = (char *)jarg2;
15932   arg3 = (Dali::Property::Value *)jarg3;
15933   if (!arg3) {
15934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15935     return ;
15936   }
15937   {
15938     try {
15939       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15940     } catch (std::out_of_range& e) {
15941       {
15942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15943       };
15944     } catch (std::exception& e) {
15945       {
15946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15947       };
15948     } catch (Dali::DaliException e) {
15949       {
15950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15951       };
15952     } catch (...) {
15953       {
15954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15955       };
15956     }
15957   }
15958
15959 }
15960
15961
15962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15963   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15964   Dali::Property::Index arg2 ;
15965   Dali::Property::Value *arg3 = 0 ;
15966
15967   arg1 = (Dali::Property::Map *)jarg1;
15968   arg2 = (Dali::Property::Index)jarg2;
15969   arg3 = (Dali::Property::Value *)jarg3;
15970   if (!arg3) {
15971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15972     return ;
15973   }
15974   {
15975     try {
15976       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15977     } catch (std::out_of_range& e) {
15978       {
15979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15980       };
15981     } catch (std::exception& e) {
15982       {
15983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15984       };
15985     } catch (Dali::DaliException e) {
15986       {
15987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15988       };
15989     } catch (...) {
15990       {
15991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15992       };
15993     }
15994   }
15995
15996 }
15997
15998
15999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16000   void * jresult ;
16001   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16002   char *arg2 = (char *) 0 ;
16003   Dali::Property::Value *arg3 = 0 ;
16004   Dali::Property::Map *result = 0 ;
16005
16006   arg1 = (Dali::Property::Map *)jarg1;
16007   arg2 = (char *)jarg2;
16008   arg3 = (Dali::Property::Value *)jarg3;
16009   if (!arg3) {
16010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16011     return 0;
16012   }
16013   {
16014     try {
16015       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16016     } catch (std::out_of_range& e) {
16017       {
16018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16019       };
16020     } catch (std::exception& e) {
16021       {
16022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16023       };
16024     } catch (Dali::DaliException e) {
16025       {
16026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16027       };
16028     } catch (...) {
16029       {
16030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16031       };
16032     }
16033   }
16034
16035   jresult = (void *)result;
16036   return jresult;
16037 }
16038
16039
16040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16041   void * jresult ;
16042   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16043   Dali::Property::Index arg2 ;
16044   Dali::Property::Value *arg3 = 0 ;
16045   Dali::Property::Map *result = 0 ;
16046
16047   arg1 = (Dali::Property::Map *)jarg1;
16048   arg2 = (Dali::Property::Index)jarg2;
16049   arg3 = (Dali::Property::Value *)jarg3;
16050   if (!arg3) {
16051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16052     return 0;
16053   }
16054   {
16055     try {
16056       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16057     } catch (std::out_of_range& e) {
16058       {
16059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16060       };
16061     } catch (std::exception& e) {
16062       {
16063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (Dali::DaliException e) {
16066       {
16067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16068       };
16069     } catch (...) {
16070       {
16071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16072       };
16073     }
16074   }
16075
16076   jresult = (void *)result;
16077   return jresult;
16078 }
16079
16080
16081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16082   void * jresult ;
16083   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16084   Dali::Property::Map::SizeType arg2 ;
16085   Dali::Property::Value *result = 0 ;
16086
16087   arg1 = (Dali::Property::Map *)jarg1;
16088   arg2 = (Dali::Property::Map::SizeType)jarg2;
16089   {
16090     try {
16091       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16092     } catch (std::out_of_range& e) {
16093       {
16094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16095       };
16096     } catch (std::exception& e) {
16097       {
16098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16099       };
16100     } catch (Dali::DaliException e) {
16101       {
16102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16103       };
16104     } catch (...) {
16105       {
16106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16107       };
16108     }
16109   }
16110
16111   jresult = (void *)result;
16112   return jresult;
16113 }
16114
16115
16116 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16117   char * jresult ;
16118   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16119   Dali::Property::Map::SizeType arg2 ;
16120   std::string *result = 0 ;
16121
16122   arg1 = (Dali::Property::Map *)jarg1;
16123   arg2 = (Dali::Property::Map::SizeType)jarg2;
16124   {
16125     try {
16126       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16127     } catch (std::out_of_range& e) {
16128       {
16129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16130       };
16131     } catch (std::exception& e) {
16132       {
16133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16134       };
16135     } catch (Dali::DaliException e) {
16136       {
16137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16138       };
16139     } catch (...) {
16140       {
16141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16142       };
16143     }
16144   }
16145
16146   jresult = SWIG_csharp_string_callback(result->c_str());
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16152   void * jresult ;
16153   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16154   Dali::Property::Map::SizeType arg2 ;
16155   SwigValueWrapper< Dali::Property::Key > result;
16156
16157   arg1 = (Dali::Property::Map *)jarg1;
16158   arg2 = (Dali::Property::Map::SizeType)jarg2;
16159   {
16160     try {
16161       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16169       };
16170     } catch (Dali::DaliException e) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16173       };
16174     } catch (...) {
16175       {
16176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16177       };
16178     }
16179   }
16180
16181   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16182   return jresult;
16183 }
16184
16185
16186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16187   void * jresult ;
16188   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16189   Dali::Property::Map::SizeType arg2 ;
16190   StringValuePair *result = 0 ;
16191
16192   arg1 = (Dali::Property::Map *)jarg1;
16193   arg2 = (Dali::Property::Map::SizeType)jarg2;
16194   {
16195     try {
16196       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16197     } catch (std::out_of_range& e) {
16198       {
16199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16200       };
16201     } catch (std::exception& e) {
16202       {
16203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (Dali::DaliException e) {
16206       {
16207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16208       };
16209     } catch (...) {
16210       {
16211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16212       };
16213     }
16214   }
16215
16216   jresult = (void *)result;
16217   return jresult;
16218 }
16219
16220
16221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16222   void * jresult ;
16223   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16224   char *arg2 = (char *) 0 ;
16225   Dali::Property::Value *result = 0 ;
16226
16227   arg1 = (Dali::Property::Map *)jarg1;
16228   arg2 = (char *)jarg2;
16229   {
16230     try {
16231       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16232     } catch (std::out_of_range& e) {
16233       {
16234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (std::exception& e) {
16237       {
16238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16239       };
16240     } catch (Dali::DaliException e) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16243       };
16244     } catch (...) {
16245       {
16246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16247       };
16248     }
16249   }
16250
16251   jresult = (void *)result;
16252   return jresult;
16253 }
16254
16255
16256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16257   void * jresult ;
16258   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16259   Dali::Property::Index arg2 ;
16260   Dali::Property::Value *result = 0 ;
16261
16262   arg1 = (Dali::Property::Map *)jarg1;
16263   arg2 = (Dali::Property::Index)jarg2;
16264   {
16265     try {
16266       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16267     } catch (std::out_of_range& e) {
16268       {
16269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16270       };
16271     } catch (std::exception& e) {
16272       {
16273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16274       };
16275     } catch (Dali::DaliException e) {
16276       {
16277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16278       };
16279     } catch (...) {
16280       {
16281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16282       };
16283     }
16284   }
16285
16286   jresult = (void *)result;
16287   return jresult;
16288 }
16289
16290
16291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16292   void * jresult ;
16293   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16294   Dali::Property::Index arg2 ;
16295   std::string *arg3 = 0 ;
16296   Dali::Property::Value *result = 0 ;
16297
16298   arg1 = (Dali::Property::Map *)jarg1;
16299   arg2 = (Dali::Property::Index)jarg2;
16300   if (!jarg3) {
16301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16302     return 0;
16303   }
16304   std::string arg3_str(jarg3);
16305   arg3 = &arg3_str;
16306   {
16307     try {
16308       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16309     } catch (std::out_of_range& e) {
16310       {
16311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16312       };
16313     } catch (std::exception& e) {
16314       {
16315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (Dali::DaliException e) {
16318       {
16319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16320       };
16321     } catch (...) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16324       };
16325     }
16326   }
16327
16328   jresult = (void *)result;
16329
16330   //argout typemap for const std::string&
16331
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16337   void * jresult ;
16338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16339   std::string *arg2 = 0 ;
16340   Dali::Property::Type arg3 ;
16341   Dali::Property::Value *result = 0 ;
16342
16343   arg1 = (Dali::Property::Map *)jarg1;
16344   if (!jarg2) {
16345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16346     return 0;
16347   }
16348   std::string arg2_str(jarg2);
16349   arg2 = &arg2_str;
16350   arg3 = (Dali::Property::Type)jarg3;
16351   {
16352     try {
16353       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16354     } catch (std::out_of_range& e) {
16355       {
16356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16357       };
16358     } catch (std::exception& e) {
16359       {
16360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (Dali::DaliException e) {
16363       {
16364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372
16373   jresult = (void *)result;
16374
16375   //argout typemap for const std::string&
16376
16377   return jresult;
16378 }
16379
16380
16381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16382   void * jresult ;
16383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16384   Dali::Property::Index arg2 ;
16385   Dali::Property::Type arg3 ;
16386   Dali::Property::Value *result = 0 ;
16387
16388   arg1 = (Dali::Property::Map *)jarg1;
16389   arg2 = (Dali::Property::Index)jarg2;
16390   arg3 = (Dali::Property::Type)jarg3;
16391   {
16392     try {
16393       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16394     } catch (std::out_of_range& e) {
16395       {
16396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16397       };
16398     } catch (std::exception& e) {
16399       {
16400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (Dali::DaliException e) {
16403       {
16404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412
16413   jresult = (void *)result;
16414   return jresult;
16415 }
16416
16417
16418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16419   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16420
16421   arg1 = (Dali::Property::Map *)jarg1;
16422   {
16423     try {
16424       (arg1)->Clear();
16425     } catch (std::out_of_range& e) {
16426       {
16427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16428       };
16429     } catch (std::exception& e) {
16430       {
16431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16432       };
16433     } catch (Dali::DaliException e) {
16434       {
16435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16436       };
16437     } catch (...) {
16438       {
16439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16440       };
16441     }
16442   }
16443
16444 }
16445
16446
16447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16448   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16449   Dali::Property::Map *arg2 = 0 ;
16450
16451   arg1 = (Dali::Property::Map *)jarg1;
16452   arg2 = (Dali::Property::Map *)jarg2;
16453   if (!arg2) {
16454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16455     return ;
16456   }
16457   {
16458     try {
16459       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16460     } catch (std::out_of_range& e) {
16461       {
16462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16463       };
16464     } catch (std::exception& e) {
16465       {
16466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16467       };
16468     } catch (Dali::DaliException e) {
16469       {
16470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16471       };
16472     } catch (...) {
16473       {
16474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16475       };
16476     }
16477   }
16478
16479 }
16480
16481
16482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16483   void * jresult ;
16484   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16485   std::string *arg2 = 0 ;
16486   Dali::Property::Value *result = 0 ;
16487
16488   arg1 = (Dali::Property::Map *)jarg1;
16489   if (!jarg2) {
16490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16491     return 0;
16492   }
16493   std::string arg2_str(jarg2);
16494   arg2 = &arg2_str;
16495   {
16496     try {
16497       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16498     } catch (std::out_of_range& e) {
16499       {
16500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16501       };
16502     } catch (std::exception& e) {
16503       {
16504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16505       };
16506     } catch (Dali::DaliException e) {
16507       {
16508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16509       };
16510     } catch (...) {
16511       {
16512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16513       };
16514     }
16515   }
16516
16517   jresult = (void *)result;
16518
16519   //argout typemap for const std::string&
16520
16521   return jresult;
16522 }
16523
16524
16525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16526   void * jresult ;
16527   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16528   Dali::Property::Index arg2 ;
16529   Dali::Property::Value *result = 0 ;
16530
16531   arg1 = (Dali::Property::Map *)jarg1;
16532   arg2 = (Dali::Property::Index)jarg2;
16533   {
16534     try {
16535       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16536     } catch (std::out_of_range& e) {
16537       {
16538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16539       };
16540     } catch (std::exception& e) {
16541       {
16542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16543       };
16544     } catch (Dali::DaliException e) {
16545       {
16546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16547       };
16548     } catch (...) {
16549       {
16550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16551       };
16552     }
16553   }
16554
16555   jresult = (void *)result;
16556   return jresult;
16557 }
16558
16559
16560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16561   void * jresult ;
16562   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16563   Dali::Property::Map *arg2 = 0 ;
16564   Dali::Property::Map *result = 0 ;
16565
16566   arg1 = (Dali::Property::Map *)jarg1;
16567   arg2 = (Dali::Property::Map *)jarg2;
16568   if (!arg2) {
16569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16570     return 0;
16571   }
16572   {
16573     try {
16574       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16575     } catch (std::out_of_range& e) {
16576       {
16577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (std::exception& e) {
16580       {
16581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16582       };
16583     } catch (Dali::DaliException e) {
16584       {
16585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16586       };
16587     } catch (...) {
16588       {
16589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16590       };
16591     }
16592   }
16593
16594   jresult = (void *)result;
16595   return jresult;
16596 }
16597
16598
16599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16600
16601   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16602
16603   if (!jarg2) {
16604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16605     return;
16606   }
16607   std::string arg2_str(jarg2);
16608   std::string* arg2 = &arg2_str;
16609
16610   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16611
16612   {
16613     try {
16614       arg1->operator[]((std::string const &)*arg2) = *arg3;
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16622       };
16623     } catch (Dali::DaliException e) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16626       };
16627     } catch (...) {
16628       {
16629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16630       };
16631     }
16632   }
16633 }
16634
16635
16636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16637
16638   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16639   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16640   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16641
16642   {
16643     try {
16644       arg1->operator[](arg2) = *arg3;
16645     } catch (std::out_of_range& e) {
16646       {
16647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16648       };
16649     } catch (std::exception& e) {
16650       {
16651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16652       };
16653     } catch (Dali::DaliException e) {
16654       {
16655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16656       };
16657     } catch (...) {
16658       {
16659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16660       };
16661     }
16662   }
16663 }
16664
16665
16666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16667   void * jresult ;
16668   Dali::Property::Value *result = 0 ;
16669
16670   {
16671     try {
16672       result = (Dali::Property::Value *)new Dali::Property::Value();
16673     } catch (std::out_of_range& e) {
16674       {
16675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16676       };
16677     } catch (std::exception& e) {
16678       {
16679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16680       };
16681     } catch (Dali::DaliException e) {
16682       {
16683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16684       };
16685     } catch (...) {
16686       {
16687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16688       };
16689     }
16690   }
16691
16692   jresult = (void *)result;
16693   return jresult;
16694 }
16695
16696
16697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16698   void * jresult ;
16699   bool arg1 ;
16700   Dali::Property::Value *result = 0 ;
16701
16702   arg1 = jarg1 ? true : false;
16703   {
16704     try {
16705       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16706     } catch (std::out_of_range& e) {
16707       {
16708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16709       };
16710     } catch (std::exception& e) {
16711       {
16712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16713       };
16714     } catch (Dali::DaliException e) {
16715       {
16716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16717       };
16718     } catch (...) {
16719       {
16720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16721       };
16722     }
16723   }
16724
16725   jresult = (void *)result;
16726   return jresult;
16727 }
16728
16729
16730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16731   void * jresult ;
16732   int arg1 ;
16733   Dali::Property::Value *result = 0 ;
16734
16735   arg1 = (int)jarg1;
16736   {
16737     try {
16738       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16739     } catch (std::out_of_range& e) {
16740       {
16741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16742       };
16743     } catch (std::exception& e) {
16744       {
16745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16746       };
16747     } catch (Dali::DaliException e) {
16748       {
16749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16750       };
16751     } catch (...) {
16752       {
16753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16754       };
16755     }
16756   }
16757
16758   jresult = (void *)result;
16759   return jresult;
16760 }
16761
16762
16763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16764   void * jresult ;
16765   float arg1 ;
16766   Dali::Property::Value *result = 0 ;
16767
16768   arg1 = (float)jarg1;
16769   {
16770     try {
16771       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16772     } catch (std::out_of_range& e) {
16773       {
16774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16775       };
16776     } catch (std::exception& e) {
16777       {
16778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16779       };
16780     } catch (Dali::DaliException e) {
16781       {
16782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16783       };
16784     } catch (...) {
16785       {
16786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16787       };
16788     }
16789   }
16790
16791   jresult = (void *)result;
16792   return jresult;
16793 }
16794
16795
16796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16797   void * jresult ;
16798   Dali::Vector2 *arg1 = 0 ;
16799   Dali::Property::Value *result = 0 ;
16800
16801   arg1 = (Dali::Vector2 *)jarg1;
16802   if (!arg1) {
16803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16804     return 0;
16805   }
16806   {
16807     try {
16808       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16809     } catch (std::out_of_range& e) {
16810       {
16811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16812       };
16813     } catch (std::exception& e) {
16814       {
16815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16816       };
16817     } catch (Dali::DaliException e) {
16818       {
16819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16820       };
16821     } catch (...) {
16822       {
16823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16824       };
16825     }
16826   }
16827
16828   jresult = (void *)result;
16829   return jresult;
16830 }
16831
16832
16833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16834   void * jresult ;
16835   Dali::Vector3 *arg1 = 0 ;
16836   Dali::Property::Value *result = 0 ;
16837
16838   arg1 = (Dali::Vector3 *)jarg1;
16839   if (!arg1) {
16840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16841     return 0;
16842   }
16843   {
16844     try {
16845       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16846     } catch (std::out_of_range& e) {
16847       {
16848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16849       };
16850     } catch (std::exception& e) {
16851       {
16852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16853       };
16854     } catch (Dali::DaliException e) {
16855       {
16856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16857       };
16858     } catch (...) {
16859       {
16860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16861       };
16862     }
16863   }
16864
16865   jresult = (void *)result;
16866   return jresult;
16867 }
16868
16869
16870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16871   void * jresult ;
16872   Dali::Vector4 *arg1 = 0 ;
16873   Dali::Property::Value *result = 0 ;
16874
16875   arg1 = (Dali::Vector4 *)jarg1;
16876   if (!arg1) {
16877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16878     return 0;
16879   }
16880   {
16881     try {
16882       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16883     } catch (std::out_of_range& e) {
16884       {
16885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16886       };
16887     } catch (std::exception& e) {
16888       {
16889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16890       };
16891     } catch (Dali::DaliException e) {
16892       {
16893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16894       };
16895     } catch (...) {
16896       {
16897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16898       };
16899     }
16900   }
16901
16902   jresult = (void *)result;
16903   return jresult;
16904 }
16905
16906
16907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16908   void * jresult ;
16909   Dali::Matrix3 *arg1 = 0 ;
16910   Dali::Property::Value *result = 0 ;
16911
16912   arg1 = (Dali::Matrix3 *)jarg1;
16913   if (!arg1) {
16914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16915     return 0;
16916   }
16917   {
16918     try {
16919       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16920     } catch (std::out_of_range& e) {
16921       {
16922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16923       };
16924     } catch (std::exception& e) {
16925       {
16926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16927       };
16928     } catch (Dali::DaliException e) {
16929       {
16930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16931       };
16932     } catch (...) {
16933       {
16934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16935       };
16936     }
16937   }
16938
16939   jresult = (void *)result;
16940   return jresult;
16941 }
16942
16943
16944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16945   void * jresult ;
16946   Dali::Matrix *arg1 = 0 ;
16947   Dali::Property::Value *result = 0 ;
16948
16949   arg1 = (Dali::Matrix *)jarg1;
16950   if (!arg1) {
16951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16952     return 0;
16953   }
16954   {
16955     try {
16956       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16957     } catch (std::out_of_range& e) {
16958       {
16959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16960       };
16961     } catch (std::exception& e) {
16962       {
16963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16964       };
16965     } catch (Dali::DaliException e) {
16966       {
16967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16968       };
16969     } catch (...) {
16970       {
16971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16972       };
16973     }
16974   }
16975
16976   jresult = (void *)result;
16977   return jresult;
16978 }
16979
16980
16981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16982   void * jresult ;
16983   Dali::Rect< int > *arg1 = 0 ;
16984   Dali::Property::Value *result = 0 ;
16985
16986   arg1 = (Dali::Rect< int > *)jarg1;
16987   if (!arg1) {
16988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16989     return 0;
16990   }
16991   {
16992     try {
16993       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16994     } catch (std::out_of_range& e) {
16995       {
16996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16997       };
16998     } catch (std::exception& e) {
16999       {
17000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17001       };
17002     } catch (Dali::DaliException e) {
17003       {
17004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17005       };
17006     } catch (...) {
17007       {
17008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17009       };
17010     }
17011   }
17012
17013   jresult = (void *)result;
17014   return jresult;
17015 }
17016
17017
17018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17019   void * jresult ;
17020   Dali::AngleAxis *arg1 = 0 ;
17021   Dali::Property::Value *result = 0 ;
17022
17023   arg1 = (Dali::AngleAxis *)jarg1;
17024   if (!arg1) {
17025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17026     return 0;
17027   }
17028   {
17029     try {
17030       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17031     } catch (std::out_of_range& e) {
17032       {
17033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17034       };
17035     } catch (std::exception& e) {
17036       {
17037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17038       };
17039     } catch (Dali::DaliException e) {
17040       {
17041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17042       };
17043     } catch (...) {
17044       {
17045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17046       };
17047     }
17048   }
17049
17050   jresult = (void *)result;
17051   return jresult;
17052 }
17053
17054
17055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17056   void * jresult ;
17057   Dali::Quaternion *arg1 = 0 ;
17058   Dali::Property::Value *result = 0 ;
17059
17060   arg1 = (Dali::Quaternion *)jarg1;
17061   if (!arg1) {
17062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17063     return 0;
17064   }
17065   {
17066     try {
17067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17068     } catch (std::out_of_range& e) {
17069       {
17070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17071       };
17072     } catch (std::exception& e) {
17073       {
17074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17075       };
17076     } catch (Dali::DaliException e) {
17077       {
17078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17079       };
17080     } catch (...) {
17081       {
17082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17083       };
17084     }
17085   }
17086
17087   jresult = (void *)result;
17088   return jresult;
17089 }
17090
17091
17092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17093   void * jresult ;
17094   std::string *arg1 = 0 ;
17095   Dali::Property::Value *result = 0 ;
17096
17097   if (!jarg1) {
17098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17099     return 0;
17100   }
17101   std::string arg1_str(jarg1);
17102   arg1 = &arg1_str;
17103   {
17104     try {
17105       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17106     } catch (std::out_of_range& e) {
17107       {
17108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17109       };
17110     } catch (std::exception& e) {
17111       {
17112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17113       };
17114     } catch (Dali::DaliException e) {
17115       {
17116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17117       };
17118     } catch (...) {
17119       {
17120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17121       };
17122     }
17123   }
17124
17125   jresult = (void *)result;
17126
17127   //argout typemap for const std::string&
17128
17129   return jresult;
17130 }
17131
17132
17133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17134   void * jresult ;
17135   Dali::Property::Array *arg1 = 0 ;
17136   Dali::Property::Value *result = 0 ;
17137
17138   arg1 = (Dali::Property::Array *)jarg1;
17139   if (!arg1) {
17140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17141     return 0;
17142   }
17143   {
17144     try {
17145       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17146     } catch (std::out_of_range& e) {
17147       {
17148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17149       };
17150     } catch (std::exception& e) {
17151       {
17152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17153       };
17154     } catch (Dali::DaliException e) {
17155       {
17156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17157       };
17158     } catch (...) {
17159       {
17160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17161       };
17162     }
17163   }
17164
17165   jresult = (void *)result;
17166   return jresult;
17167 }
17168
17169
17170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17171   void * jresult ;
17172   Dali::Property::Map *arg1 = 0 ;
17173   Dali::Property::Value *result = 0 ;
17174
17175   arg1 = (Dali::Property::Map *)jarg1;
17176   if (!arg1) {
17177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17178     return 0;
17179   }
17180   {
17181     try {
17182       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17183     } catch (std::out_of_range& e) {
17184       {
17185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17186       };
17187     } catch (std::exception& e) {
17188       {
17189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (Dali::DaliException e) {
17192       {
17193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17194       };
17195     } catch (...) {
17196       {
17197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17198       };
17199     }
17200   }
17201
17202   jresult = (void *)result;
17203   return jresult;
17204 }
17205
17206
17207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17208   void * jresult ;
17209   Extents *arg1 = 0 ;
17210   Dali::Property::Value *result = 0 ;
17211
17212   arg1 = (Extents *)jarg1;
17213   if (!arg1) {
17214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17215     return 0;
17216   }
17217   {
17218     try {
17219       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17220     } catch (std::out_of_range& e) {
17221       {
17222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17223       };
17224     } catch (std::exception& e) {
17225       {
17226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (...) {
17229       {
17230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17231       };
17232     }
17233   }
17234   jresult = (void *)result;
17235   return jresult;
17236 }
17237
17238
17239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17240   void * jresult ;
17241   Dali::Property::Type arg1 ;
17242   Dali::Property::Value *result = 0 ;
17243
17244   arg1 = (Dali::Property::Type)jarg1;
17245   {
17246     try {
17247       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17248     } catch (std::out_of_range& e) {
17249       {
17250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17251       };
17252     } catch (std::exception& e) {
17253       {
17254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17255       };
17256     } catch (Dali::DaliException e) {
17257       {
17258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17259       };
17260     } catch (...) {
17261       {
17262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17263       };
17264     }
17265   }
17266
17267   jresult = (void *)result;
17268   return jresult;
17269 }
17270
17271
17272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17273   void * jresult ;
17274   Dali::Property::Value *arg1 = 0 ;
17275   Dali::Property::Value *result = 0 ;
17276
17277   arg1 = (Dali::Property::Value *)jarg1;
17278   if (!arg1) {
17279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17280     return 0;
17281   }
17282   {
17283     try {
17284       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17285     } catch (std::out_of_range& e) {
17286       {
17287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17288       };
17289     } catch (std::exception& e) {
17290       {
17291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17292       };
17293     } catch (Dali::DaliException e) {
17294       {
17295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17296       };
17297     } catch (...) {
17298       {
17299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17300       };
17301     }
17302   }
17303
17304   jresult = (void *)result;
17305   return jresult;
17306 }
17307
17308
17309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17310   void * jresult ;
17311   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17312   Dali::Property::Value *arg2 = 0 ;
17313   Dali::Property::Value *result = 0 ;
17314
17315   arg1 = (Dali::Property::Value *)jarg1;
17316   arg2 = (Dali::Property::Value *)jarg2;
17317   if (!arg2) {
17318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17319     return 0;
17320   }
17321   {
17322     try {
17323       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17324     } catch (std::out_of_range& e) {
17325       {
17326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17327       };
17328     } catch (std::exception& e) {
17329       {
17330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17331       };
17332     } catch (Dali::DaliException e) {
17333       {
17334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17335       };
17336     } catch (...) {
17337       {
17338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17339       };
17340     }
17341   }
17342
17343   jresult = (void *)result;
17344   return jresult;
17345 }
17346
17347
17348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17349   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17350
17351   arg1 = (Dali::Property::Value *)jarg1;
17352   {
17353     try {
17354       delete arg1;
17355     } catch (std::out_of_range& e) {
17356       {
17357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17358       };
17359     } catch (std::exception& e) {
17360       {
17361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17362       };
17363     } catch (Dali::DaliException e) {
17364       {
17365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17366       };
17367     } catch (...) {
17368       {
17369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17370       };
17371     }
17372   }
17373
17374 }
17375
17376
17377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17378   int jresult ;
17379   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17380   Dali::Property::Type result;
17381
17382   arg1 = (Dali::Property::Value *)jarg1;
17383   {
17384     try {
17385       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17386     } catch (std::out_of_range& e) {
17387       {
17388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17389       };
17390     } catch (std::exception& e) {
17391       {
17392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17393       };
17394     } catch (Dali::DaliException e) {
17395       {
17396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17397       };
17398     } catch (...) {
17399       {
17400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17401       };
17402     }
17403   }
17404
17405   jresult = (int)result;
17406   return jresult;
17407 }
17408
17409
17410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17411   unsigned int jresult ;
17412   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17413   bool *arg2 = 0 ;
17414   bool result;
17415
17416   arg1 = (Dali::Property::Value *)jarg1;
17417   arg2 = (bool *)jarg2;
17418   {
17419     try {
17420       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17421     } catch (std::out_of_range& e) {
17422       {
17423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17424       };
17425     } catch (std::exception& e) {
17426       {
17427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17428       };
17429     } catch (Dali::DaliException e) {
17430       {
17431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17432       };
17433     } catch (...) {
17434       {
17435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17436       };
17437     }
17438   }
17439
17440   jresult = result;
17441   return jresult;
17442 }
17443
17444
17445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17446   unsigned int jresult ;
17447   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17448   float *arg2 = 0 ;
17449   bool result;
17450
17451   arg1 = (Dali::Property::Value *)jarg1;
17452   arg2 = (float *)jarg2;
17453   {
17454     try {
17455       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17456     } catch (std::out_of_range& e) {
17457       {
17458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17459       };
17460     } catch (std::exception& e) {
17461       {
17462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17463       };
17464     } catch (Dali::DaliException e) {
17465       {
17466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17467       };
17468     } catch (...) {
17469       {
17470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17471       };
17472     }
17473   }
17474
17475   jresult = result;
17476   return jresult;
17477 }
17478
17479
17480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17481   unsigned int jresult ;
17482   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17483   int *arg2 = 0 ;
17484   bool result;
17485
17486   arg1 = (Dali::Property::Value *)jarg1;
17487   arg2 = (int *)jarg2;
17488   {
17489     try {
17490       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17491     } catch (std::out_of_range& e) {
17492       {
17493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17494       };
17495     } catch (std::exception& e) {
17496       {
17497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17498       };
17499     } catch (Dali::DaliException e) {
17500       {
17501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17502       };
17503     } catch (...) {
17504       {
17505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17506       };
17507     }
17508   }
17509
17510   jresult = result;
17511   return jresult;
17512 }
17513
17514
17515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17516   unsigned int jresult ;
17517   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17518   Dali::Rect< int > *arg2 = 0 ;
17519   bool result;
17520
17521   arg1 = (Dali::Property::Value *)jarg1;
17522   arg2 = (Dali::Rect< int > *)jarg2;
17523   if (!arg2) {
17524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17525     return 0;
17526   }
17527   {
17528     try {
17529       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17530     } catch (std::out_of_range& e) {
17531       {
17532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17533       };
17534     } catch (std::exception& e) {
17535       {
17536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17537       };
17538     } catch (Dali::DaliException e) {
17539       {
17540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17541       };
17542     } catch (...) {
17543       {
17544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17545       };
17546     }
17547   }
17548
17549   jresult = result;
17550   return jresult;
17551 }
17552
17553
17554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17555   unsigned int jresult ;
17556   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17557   Dali::Vector2 *arg2 = 0 ;
17558   bool result;
17559
17560   arg1 = (Dali::Property::Value *)jarg1;
17561   arg2 = (Dali::Vector2 *)jarg2;
17562   if (!arg2) {
17563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17564     return 0;
17565   }
17566   {
17567     try {
17568       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17569     } catch (std::out_of_range& e) {
17570       {
17571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17572       };
17573     } catch (std::exception& e) {
17574       {
17575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17576       };
17577     } catch (Dali::DaliException e) {
17578       {
17579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17580       };
17581     } catch (...) {
17582       {
17583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17584       };
17585     }
17586   }
17587
17588   jresult = result;
17589   return jresult;
17590 }
17591
17592
17593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17594   unsigned int jresult ;
17595   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17596   Dali::Vector3 *arg2 = 0 ;
17597   bool result;
17598
17599   arg1 = (Dali::Property::Value *)jarg1;
17600   arg2 = (Dali::Vector3 *)jarg2;
17601   if (!arg2) {
17602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17603     return 0;
17604   }
17605   {
17606     try {
17607       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17608     } catch (std::out_of_range& e) {
17609       {
17610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17611       };
17612     } catch (std::exception& e) {
17613       {
17614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17615       };
17616     } catch (Dali::DaliException e) {
17617       {
17618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17619       };
17620     } catch (...) {
17621       {
17622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17623       };
17624     }
17625   }
17626
17627   jresult = result;
17628   return jresult;
17629 }
17630
17631
17632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17633   unsigned int jresult ;
17634   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17635   Dali::Vector4 *arg2 = 0 ;
17636   bool result;
17637
17638   arg1 = (Dali::Property::Value *)jarg1;
17639   arg2 = (Dali::Vector4 *)jarg2;
17640   if (!arg2) {
17641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17642     return 0;
17643   }
17644   {
17645     try {
17646       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17647     } catch (std::out_of_range& e) {
17648       {
17649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17650       };
17651     } catch (std::exception& e) {
17652       {
17653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17654       };
17655     } catch (Dali::DaliException e) {
17656       {
17657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17658       };
17659     } catch (...) {
17660       {
17661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17662       };
17663     }
17664   }
17665
17666   jresult = result;
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17672   unsigned int jresult ;
17673   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17674   Dali::Matrix3 *arg2 = 0 ;
17675   bool result;
17676
17677   arg1 = (Dali::Property::Value *)jarg1;
17678   arg2 = (Dali::Matrix3 *)jarg2;
17679   if (!arg2) {
17680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17681     return 0;
17682   }
17683   {
17684     try {
17685       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17686     } catch (std::out_of_range& e) {
17687       {
17688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17689       };
17690     } catch (std::exception& e) {
17691       {
17692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17693       };
17694     } catch (Dali::DaliException e) {
17695       {
17696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17697       };
17698     } catch (...) {
17699       {
17700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17701       };
17702     }
17703   }
17704
17705   jresult = result;
17706   return jresult;
17707 }
17708
17709
17710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17711   unsigned int jresult ;
17712   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17713   Dali::Matrix *arg2 = 0 ;
17714   bool result;
17715
17716   arg1 = (Dali::Property::Value *)jarg1;
17717   arg2 = (Dali::Matrix *)jarg2;
17718   if (!arg2) {
17719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17720     return 0;
17721   }
17722   {
17723     try {
17724       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17725     } catch (std::out_of_range& e) {
17726       {
17727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17728       };
17729     } catch (std::exception& e) {
17730       {
17731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17732       };
17733     } catch (Dali::DaliException e) {
17734       {
17735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17736       };
17737     } catch (...) {
17738       {
17739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17740       };
17741     }
17742   }
17743
17744   jresult = result;
17745   return jresult;
17746 }
17747
17748
17749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17750   unsigned int jresult ;
17751   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17752   Dali::AngleAxis *arg2 = 0 ;
17753   bool result;
17754
17755   arg1 = (Dali::Property::Value *)jarg1;
17756   arg2 = (Dali::AngleAxis *)jarg2;
17757   if (!arg2) {
17758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17759     return 0;
17760   }
17761   {
17762     try {
17763       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17764     } catch (std::out_of_range& e) {
17765       {
17766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (std::exception& e) {
17769       {
17770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17771       };
17772     } catch (Dali::DaliException e) {
17773       {
17774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17779       };
17780     }
17781   }
17782
17783   jresult = result;
17784   return jresult;
17785 }
17786
17787
17788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17789   unsigned int jresult ;
17790   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17791   Dali::Quaternion *arg2 = 0 ;
17792   bool result;
17793
17794   arg1 = (Dali::Property::Value *)jarg1;
17795   arg2 = (Dali::Quaternion *)jarg2;
17796   if (!arg2) {
17797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17798     return 0;
17799   }
17800   {
17801     try {
17802       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17803     } catch (std::out_of_range& e) {
17804       {
17805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (std::exception& e) {
17808       {
17809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17810       };
17811     } catch (Dali::DaliException e) {
17812       {
17813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17814       };
17815     } catch (...) {
17816       {
17817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17818       };
17819     }
17820   }
17821
17822   jresult = result;
17823   return jresult;
17824 }
17825
17826
17827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17828   unsigned int jresult ;
17829   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17830   std::string *arg2 = 0 ;
17831   bool result;
17832
17833   arg1 = (Dali::Property::Value *)jarg1;
17834
17835   //typemap in
17836   std::string temp;
17837   arg2 = &temp;
17838
17839   {
17840     try {
17841       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17842     } catch (std::out_of_range& e) {
17843       {
17844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17845       };
17846     } catch (std::exception& e) {
17847       {
17848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17849       };
17850     } catch (Dali::DaliException e) {
17851       {
17852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17853       };
17854     } catch (...) {
17855       {
17856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17857       };
17858     }
17859   }
17860
17861   jresult = result;
17862
17863   //Typemap argout in c++ file.
17864   //This will convert c++ string to c# string
17865   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17866
17867   return jresult;
17868 }
17869
17870
17871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17872   unsigned int jresult ;
17873   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17874   Dali::Property::Array *arg2 = 0 ;
17875   bool result;
17876
17877   arg1 = (Dali::Property::Value *)jarg1;
17878   arg2 = (Dali::Property::Array *)jarg2;
17879   if (!arg2) {
17880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17881     return 0;
17882   }
17883   {
17884     try {
17885       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17886     } catch (std::out_of_range& e) {
17887       {
17888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17889       };
17890     } catch (std::exception& e) {
17891       {
17892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17893       };
17894     } catch (Dali::DaliException e) {
17895       {
17896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17897       };
17898     } catch (...) {
17899       {
17900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17901       };
17902     }
17903   }
17904
17905   jresult = result;
17906   return jresult;
17907 }
17908
17909
17910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17911   unsigned int jresult ;
17912   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17913   Dali::Property::Map *arg2 = 0 ;
17914   bool result;
17915
17916   arg1 = (Dali::Property::Value *)jarg1;
17917   arg2 = (Dali::Property::Map *)jarg2;
17918   if (!arg2) {
17919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17920     return 0;
17921   }
17922   {
17923     try {
17924       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17925     } catch (std::out_of_range& e) {
17926       {
17927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (std::exception& e) {
17930       {
17931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17932       };
17933     } catch (Dali::DaliException e) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17936       };
17937     } catch (...) {
17938       {
17939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17940       };
17941     }
17942   }
17943
17944   jresult = result;
17945   return jresult;
17946 }
17947
17948
17949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17950   unsigned int jresult ;
17951   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17952   Extents *arg2 = 0 ;
17953   bool result;
17954
17955   arg1 = (Dali::Property::Value *)jarg1;
17956   arg2 = (Extents *)jarg2;
17957   if (!arg2) {
17958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17959     return 0;
17960   }
17961   {
17962     try {
17963       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17964     } catch (std::out_of_range& e) {
17965       {
17966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17967       };
17968     } catch (std::exception& e) {
17969       {
17970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17971       };
17972     } catch (...) {
17973       {
17974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17975       };
17976     }
17977   }
17978   jresult = result;
17979   return jresult;
17980 }
17981
17982
17983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17984   void * jresult ;
17985   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17986   Dali::Property::Array *result = 0 ;
17987
17988   arg1 = (Dali::Property::Value *)jarg1;
17989   {
17990     try {
17991       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17992     } catch (std::out_of_range& e) {
17993       {
17994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17995       };
17996     } catch (std::exception& e) {
17997       {
17998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17999       };
18000     } catch (Dali::DaliException e) {
18001       {
18002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18003       };
18004     } catch (...) {
18005       {
18006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18007       };
18008     }
18009   }
18010
18011   jresult = (void *)result;
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18017   void * jresult ;
18018   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18019   Dali::Property::Map *result = 0 ;
18020
18021   arg1 = (Dali::Property::Value *)jarg1;
18022   {
18023     try {
18024       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
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 (Dali::DaliException e) {
18034       {
18035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18036       };
18037     } catch (...) {
18038       {
18039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18040       };
18041     }
18042   }
18043
18044   jresult = (void *)result;
18045   return jresult;
18046 }
18047
18048
18049 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18050   char * jresult ;
18051   Dali::Property::Type arg1 ;
18052   char *result = 0 ;
18053
18054   arg1 = (Dali::Property::Type)jarg1;
18055   {
18056     try {
18057       result = (char *)Dali::PropertyTypes::GetName(arg1);
18058     } catch (std::out_of_range& e) {
18059       {
18060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18061       };
18062     } catch (std::exception& e) {
18063       {
18064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18065       };
18066     } catch (Dali::DaliException e) {
18067       {
18068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18069       };
18070     } catch (...) {
18071       {
18072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18073       };
18074     }
18075   }
18076
18077   jresult = SWIG_csharp_string_callback((const char *)result);
18078   return jresult;
18079 }
18080
18081
18082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18083   unsigned int jresult ;
18084   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18085   std::string *arg2 = 0 ;
18086   Dali::Property::Map *arg3 = 0 ;
18087   bool result;
18088
18089   arg1 = (Dali::BaseObject *)jarg1;
18090   if (!jarg2) {
18091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18092     return 0;
18093   }
18094   std::string arg2_str(jarg2);
18095   arg2 = &arg2_str;
18096   arg3 = (Dali::Property::Map *)jarg3;
18097   if (!arg3) {
18098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18099     return 0;
18100   }
18101   {
18102     try {
18103       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18104     } catch (std::out_of_range& e) {
18105       {
18106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (std::exception& e) {
18109       {
18110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18111       };
18112     } catch (Dali::DaliException e) {
18113       {
18114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18115       };
18116     } catch (...) {
18117       {
18118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18119       };
18120     }
18121   }
18122
18123   jresult = result;
18124
18125   //argout typemap for const std::string&
18126
18127   return jresult;
18128 }
18129
18130
18131 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18132   char * jresult ;
18133   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18134   std::string *result = 0 ;
18135
18136   arg1 = (Dali::BaseObject *)jarg1;
18137   {
18138     try {
18139       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18140     } catch (std::out_of_range& e) {
18141       {
18142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18143       };
18144     } catch (std::exception& e) {
18145       {
18146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18147       };
18148     } catch (Dali::DaliException e) {
18149       {
18150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18151       };
18152     } catch (...) {
18153       {
18154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18155       };
18156     }
18157   }
18158
18159   jresult = SWIG_csharp_string_callback(result->c_str());
18160   return jresult;
18161 }
18162
18163
18164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18165   unsigned int jresult ;
18166   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18167   Dali::TypeInfo *arg2 = 0 ;
18168   bool result;
18169
18170   arg1 = (Dali::BaseObject *)jarg1;
18171   arg2 = (Dali::TypeInfo *)jarg2;
18172   if (!arg2) {
18173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18174     return 0;
18175   }
18176   {
18177     try {
18178       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18179     } catch (std::out_of_range& e) {
18180       {
18181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18182       };
18183     } catch (std::exception& e) {
18184       {
18185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (Dali::DaliException e) {
18188       {
18189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197
18198   jresult = result;
18199   return jresult;
18200 }
18201
18202
18203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18204   unsigned int jresult ;
18205   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18206   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18207   std::string *arg3 = 0 ;
18208   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18209   bool result;
18210
18211   arg1 = (Dali::BaseObject *)jarg1;
18212   arg2 = (ConnectionTrackerInterface *)jarg2;
18213   if (!jarg3) {
18214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18215     return 0;
18216   }
18217   std::string arg3_str(jarg3);
18218   arg3 = &arg3_str;
18219   arg4 = (FunctorDelegate *)jarg4;
18220   {
18221     try {
18222       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18223     } catch (std::out_of_range& e) {
18224       {
18225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18226       };
18227     } catch (std::exception& e) {
18228       {
18229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18230       };
18231     } catch (Dali::DaliException e) {
18232       {
18233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18234       };
18235     } catch (...) {
18236       {
18237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18238       };
18239     }
18240   }
18241
18242   jresult = result;
18243
18244   //argout typemap for const std::string&
18245
18246   return jresult;
18247 }
18248
18249
18250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18251   void * jresult ;
18252   Dali::BaseHandle *arg1 = 0 ;
18253   Dali::BaseObject *result = 0 ;
18254
18255   arg1 = (Dali::BaseHandle *)jarg1;
18256   if (!arg1) {
18257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18258     return 0;
18259   }
18260   {
18261     try {
18262       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18263     } catch (std::out_of_range& e) {
18264       {
18265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18266       };
18267     } catch (std::exception& e) {
18268       {
18269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18270       };
18271     } catch (Dali::DaliException e) {
18272       {
18273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18274       };
18275     } catch (...) {
18276       {
18277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18278       };
18279     }
18280   }
18281
18282   jresult = (void *)result;
18283   return jresult;
18284 }
18285
18286
18287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18288   void * jresult ;
18289   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18290   Dali::BaseHandle *result = 0 ;
18291
18292   arg1 = (Dali::BaseObject *)jarg1;
18293   {
18294     try {
18295       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18296     } catch (std::out_of_range& e) {
18297       {
18298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18299       };
18300     } catch (std::exception& e) {
18301       {
18302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18303       };
18304     } catch (Dali::DaliException e) {
18305       {
18306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18307       };
18308     } catch (...) {
18309       {
18310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18311       };
18312     }
18313   }
18314
18315   jresult = (void *)result;
18316   return jresult;
18317 }
18318
18319
18320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18321   void * jresult ;
18322   Dali::BaseHandle *result = 0 ;
18323
18324   {
18325     try {
18326       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18327     } catch (std::out_of_range& e) {
18328       {
18329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18330       };
18331     } catch (std::exception& e) {
18332       {
18333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (Dali::DaliException e) {
18336       {
18337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18338       };
18339     } catch (...) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18342       };
18343     }
18344   }
18345
18346   jresult = (void *)result;
18347   return jresult;
18348 }
18349
18350
18351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18352   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18353
18354   arg1 = (Dali::BaseHandle *)jarg1;
18355   {
18356     try {
18357       delete arg1;
18358     } catch (std::out_of_range& e) {
18359       {
18360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18361       };
18362     } catch (std::exception& e) {
18363       {
18364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18365       };
18366     } catch (Dali::DaliException e) {
18367       {
18368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18369       };
18370     } catch (...) {
18371       {
18372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18373       };
18374     }
18375   }
18376
18377 }
18378
18379
18380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18381   void * jresult ;
18382   Dali::BaseHandle *arg1 = 0 ;
18383   Dali::BaseHandle *result = 0 ;
18384
18385   arg1 = (Dali::BaseHandle *)jarg1;
18386   if (!arg1) {
18387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18388     return 0;
18389   }
18390   {
18391     try {
18392       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18393     } catch (std::out_of_range& e) {
18394       {
18395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18396       };
18397     } catch (std::exception& e) {
18398       {
18399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18400       };
18401     } catch (Dali::DaliException e) {
18402       {
18403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18408       };
18409     }
18410   }
18411
18412   jresult = (void *)result;
18413   return jresult;
18414 }
18415
18416
18417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18418   void * jresult ;
18419   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18420   Dali::BaseHandle *arg2 = 0 ;
18421   Dali::BaseHandle *result = 0 ;
18422
18423   arg1 = (Dali::BaseHandle *)jarg1;
18424   arg2 = (Dali::BaseHandle *)jarg2;
18425   if (!arg2) {
18426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18427     return 0;
18428   }
18429   {
18430     try {
18431       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18432     } catch (std::out_of_range& e) {
18433       {
18434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18435       };
18436     } catch (std::exception& e) {
18437       {
18438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18439       };
18440     } catch (Dali::DaliException e) {
18441       {
18442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18443       };
18444     } catch (...) {
18445       {
18446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18447       };
18448     }
18449   }
18450
18451   jresult = (void *)result;
18452   return jresult;
18453 }
18454
18455
18456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18457   unsigned int jresult ;
18458   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18459   std::string *arg2 = 0 ;
18460   Dali::Property::Map *arg3 = 0 ;
18461   bool result;
18462
18463   arg1 = (Dali::BaseHandle *)jarg1;
18464   if (!jarg2) {
18465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18466     return 0;
18467   }
18468   std::string arg2_str(jarg2);
18469   arg2 = &arg2_str;
18470   arg3 = (Dali::Property::Map *)jarg3;
18471   if (!arg3) {
18472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18473     return 0;
18474   }
18475   {
18476     try {
18477       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18478     } catch (std::out_of_range& e) {
18479       {
18480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18481       };
18482     } catch (std::exception& e) {
18483       {
18484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18485       };
18486     } catch (Dali::DaliException e) {
18487       {
18488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18489       };
18490     } catch (...) {
18491       {
18492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18493       };
18494     }
18495   }
18496
18497   jresult = result;
18498
18499   //argout typemap for const std::string&
18500
18501   return jresult;
18502 }
18503
18504
18505 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18506   char * jresult ;
18507   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18508   std::string *result = 0 ;
18509
18510   arg1 = (Dali::BaseHandle *)jarg1;
18511   {
18512     try {
18513       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18514     } catch (std::out_of_range& e) {
18515       {
18516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18517       };
18518     } catch (std::exception& e) {
18519       {
18520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18521       };
18522     } catch (Dali::DaliException e) {
18523       {
18524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18525       };
18526     } catch (...) {
18527       {
18528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18529       };
18530     }
18531   }
18532
18533   jresult = SWIG_csharp_string_callback(result->c_str());
18534   return jresult;
18535 }
18536
18537
18538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18539   unsigned int jresult ;
18540   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18541   Dali::TypeInfo *arg2 = 0 ;
18542   bool result;
18543
18544   arg1 = (Dali::BaseHandle *)jarg1;
18545   arg2 = (Dali::TypeInfo *)jarg2;
18546   if (!arg2) {
18547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18548     return 0;
18549   }
18550   {
18551     try {
18552       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18553     } catch (std::out_of_range& e) {
18554       {
18555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18556       };
18557     } catch (std::exception& e) {
18558       {
18559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18560       };
18561     } catch (Dali::DaliException e) {
18562       {
18563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18564       };
18565     } catch (...) {
18566       {
18567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18568       };
18569     }
18570   }
18571
18572   jresult = result;
18573   return jresult;
18574 }
18575
18576
18577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18578   void * jresult ;
18579   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18580   Dali::BaseObject *result = 0 ;
18581
18582   arg1 = (Dali::BaseHandle *)jarg1;
18583   {
18584     try {
18585       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18586     } catch (std::out_of_range& e) {
18587       {
18588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18589       };
18590     } catch (std::exception& e) {
18591       {
18592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18593       };
18594     } catch (Dali::DaliException e) {
18595       {
18596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18597       };
18598     } catch (...) {
18599       {
18600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18601       };
18602     }
18603   }
18604
18605   jresult = (void *)result;
18606   return jresult;
18607 }
18608
18609
18610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18611   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18612
18613   arg1 = (Dali::BaseHandle *)jarg1;
18614   {
18615     try {
18616       (arg1)->Reset();
18617     } catch (std::out_of_range& e) {
18618       {
18619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18620       };
18621     } catch (std::exception& e) {
18622       {
18623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18624       };
18625     } catch (Dali::DaliException e) {
18626       {
18627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18628       };
18629     } catch (...) {
18630       {
18631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18632       };
18633     }
18634   }
18635
18636 }
18637
18638
18639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18640   unsigned int jresult ;
18641   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18642   Dali::BaseHandle *arg2 = 0 ;
18643   bool result;
18644
18645   arg1 = (Dali::BaseHandle *)jarg1;
18646   arg2 = (Dali::BaseHandle *)jarg2;
18647   if (!arg2) {
18648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18649     return 0;
18650   }
18651   {
18652     try {
18653       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18654     } catch (std::out_of_range& e) {
18655       {
18656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18657       };
18658     } catch (std::exception& e) {
18659       {
18660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18661       };
18662     } catch (Dali::DaliException e) {
18663       {
18664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18665       };
18666     } catch (...) {
18667       {
18668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18669       };
18670     }
18671   }
18672
18673   jresult = result;
18674   return jresult;
18675 }
18676
18677
18678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18679   unsigned int jresult ;
18680   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18681   Dali::BaseHandle *arg2 = 0 ;
18682   bool result;
18683
18684   arg1 = (Dali::BaseHandle *)jarg1;
18685   arg2 = (Dali::BaseHandle *)jarg2;
18686   if (!arg2) {
18687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18688     return 0;
18689   }
18690   {
18691     try {
18692       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18693     } catch (std::out_of_range& e) {
18694       {
18695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (std::exception& e) {
18698       {
18699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18700       };
18701     } catch (Dali::DaliException e) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18704       };
18705     } catch (...) {
18706       {
18707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18708       };
18709     }
18710   }
18711
18712   jresult = result;
18713   return jresult;
18714 }
18715
18716
18717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18718   void * jresult ;
18719   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18720   Dali::RefObject *result = 0 ;
18721
18722   arg1 = (Dali::BaseHandle *)jarg1;
18723   {
18724     try {
18725       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18726     } catch (std::out_of_range& e) {
18727       {
18728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18729       };
18730     } catch (std::exception& e) {
18731       {
18732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18733       };
18734     } catch (Dali::DaliException e) {
18735       {
18736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18737       };
18738     } catch (...) {
18739       {
18740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18741       };
18742     }
18743   }
18744
18745   jresult = (void *)result;
18746   return jresult;
18747 }
18748
18749
18750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18751   unsigned int jresult ;
18752   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18753   bool result;
18754
18755   arg1 = (Dali::BaseHandle *)jarg1;
18756   {
18757     try {
18758       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18759     } catch (std::out_of_range& e) {
18760       {
18761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (std::exception& e) {
18764       {
18765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18766       };
18767     } catch (Dali::DaliException e) {
18768       {
18769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18770       };
18771     } catch (...) {
18772       {
18773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18774       };
18775     }
18776   }
18777
18778   jresult = result;
18779   return jresult;
18780 }
18781
18782
18783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18784   unsigned int jresult ;
18785   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18786   Dali::BaseHandle *arg2 = 0 ;
18787   bool result;
18788
18789   arg1 = (Dali::BaseHandle *)jarg1;
18790   arg2 = (Dali::BaseHandle *)jarg2;
18791   if (!arg2) {
18792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18793     return 0;
18794   }
18795   {
18796     try {
18797       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18798     } catch (std::out_of_range& e) {
18799       {
18800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18801       };
18802     } catch (std::exception& e) {
18803       {
18804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18805       };
18806     } catch (Dali::DaliException e) {
18807       {
18808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18809       };
18810     } catch (...) {
18811       {
18812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18813       };
18814     }
18815   }
18816
18817   jresult = result;
18818   return jresult;
18819 }
18820
18821
18822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18823   unsigned int jresult ;
18824   Dali::BaseHandle *arg1 = 0 ;
18825   Dali::BaseHandle *arg2 = 0 ;
18826   bool result;
18827
18828   arg1 = (Dali::BaseHandle *)jarg1;
18829   if (!arg1) {
18830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18831     return 0;
18832   }
18833   arg2 = (Dali::BaseHandle *)jarg2;
18834   if (!arg2) {
18835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18836     return 0;
18837   }
18838   {
18839     try {
18840       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18841     } catch (std::out_of_range& e) {
18842       {
18843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18844       };
18845     } catch (std::exception& e) {
18846       {
18847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18848       };
18849     } catch (Dali::DaliException e) {
18850       {
18851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18852       };
18853     } catch (...) {
18854       {
18855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18856       };
18857     }
18858   }
18859
18860   jresult = result;
18861   return jresult;
18862 }
18863
18864
18865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18866   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18867
18868   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18869   {
18870     try {
18871       delete arg1;
18872     } catch (std::out_of_range& e) {
18873       {
18874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18875       };
18876     } catch (std::exception& e) {
18877       {
18878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18879       };
18880     } catch (Dali::DaliException e) {
18881       {
18882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18883       };
18884     } catch (...) {
18885       {
18886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18887       };
18888     }
18889   }
18890
18891 }
18892
18893
18894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18895   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18896   SlotObserver *arg2 = (SlotObserver *) 0 ;
18897   CallbackBase *arg3 = (CallbackBase *) 0 ;
18898
18899   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18900   arg2 = (SlotObserver *)jarg2;
18901   arg3 = (CallbackBase *)jarg3;
18902   {
18903     try {
18904       (arg1)->SignalConnected(arg2,arg3);
18905     } catch (std::out_of_range& e) {
18906       {
18907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18908       };
18909     } catch (std::exception& e) {
18910       {
18911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18912       };
18913     } catch (Dali::DaliException e) {
18914       {
18915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18916       };
18917     } catch (...) {
18918       {
18919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18920       };
18921     }
18922   }
18923
18924 }
18925
18926
18927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18928   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18929
18930   arg1 = (Dali::SignalObserver *)jarg1;
18931   {
18932     try {
18933       delete arg1;
18934     } catch (std::out_of_range& e) {
18935       {
18936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18937       };
18938     } catch (std::exception& e) {
18939       {
18940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18941       };
18942     } catch (Dali::DaliException e) {
18943       {
18944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18945       };
18946     } catch (...) {
18947       {
18948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18949       };
18950     }
18951   }
18952
18953 }
18954
18955
18956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18957   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18958   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18959   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18960
18961   arg1 = (Dali::SignalObserver *)jarg1;
18962   arg2 = (Dali::SlotObserver *)jarg2;
18963   arg3 = (Dali::CallbackBase *)jarg3;
18964   {
18965     try {
18966       (arg1)->SignalDisconnected(arg2,arg3);
18967     } catch (std::out_of_range& e) {
18968       {
18969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18970       };
18971     } catch (std::exception& e) {
18972       {
18973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18974       };
18975     } catch (Dali::DaliException e) {
18976       {
18977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18978       };
18979     } catch (...) {
18980       {
18981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18982       };
18983     }
18984   }
18985
18986 }
18987
18988
18989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18990   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18991
18992   arg1 = (Dali::SlotObserver *)jarg1;
18993   {
18994     try {
18995       delete arg1;
18996     } catch (std::out_of_range& e) {
18997       {
18998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18999       };
19000     } catch (std::exception& e) {
19001       {
19002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19003       };
19004     } catch (Dali::DaliException e) {
19005       {
19006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19007       };
19008     } catch (...) {
19009       {
19010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19011       };
19012     }
19013   }
19014
19015 }
19016
19017
19018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19019   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19020   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19021
19022   arg1 = (Dali::SlotObserver *)jarg1;
19023   arg2 = (Dali::CallbackBase *)jarg2;
19024   {
19025     try {
19026       (arg1)->SlotDisconnected(arg2);
19027     } catch (std::out_of_range& e) {
19028       {
19029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19030       };
19031     } catch (std::exception& e) {
19032       {
19033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19034       };
19035     } catch (Dali::DaliException e) {
19036       {
19037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19038       };
19039     } catch (...) {
19040       {
19041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19042       };
19043     }
19044   }
19045
19046 }
19047
19048
19049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19050   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19051
19052   arg1 = (Dali::ConnectionTracker *)jarg1;
19053   {
19054     try {
19055       delete arg1;
19056     } catch (std::out_of_range& e) {
19057       {
19058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19059       };
19060     } catch (std::exception& e) {
19061       {
19062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19063       };
19064     } catch (Dali::DaliException e) {
19065       {
19066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19067       };
19068     } catch (...) {
19069       {
19070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19071       };
19072     }
19073   }
19074
19075 }
19076
19077
19078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19079   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19080
19081   arg1 = (Dali::ConnectionTracker *)jarg1;
19082   {
19083     try {
19084       (arg1)->DisconnectAll();
19085     } catch (std::out_of_range& e) {
19086       {
19087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19088       };
19089     } catch (std::exception& e) {
19090       {
19091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19092       };
19093     } catch (Dali::DaliException e) {
19094       {
19095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19096       };
19097     } catch (...) {
19098       {
19099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19100       };
19101     }
19102   }
19103
19104 }
19105
19106
19107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19108   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19109   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19110   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19111
19112   arg1 = (Dali::ConnectionTracker *)jarg1;
19113   arg2 = (Dali::SlotObserver *)jarg2;
19114   arg3 = (Dali::CallbackBase *)jarg3;
19115   {
19116     try {
19117       (arg1)->SignalConnected(arg2,arg3);
19118     } catch (std::out_of_range& e) {
19119       {
19120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19121       };
19122     } catch (std::exception& e) {
19123       {
19124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19125       };
19126     } catch (Dali::DaliException e) {
19127       {
19128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19129       };
19130     } catch (...) {
19131       {
19132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19133       };
19134     }
19135   }
19136
19137 }
19138
19139
19140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19141   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19142   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19143   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19144
19145   arg1 = (Dali::ConnectionTracker *)jarg1;
19146   arg2 = (Dali::SlotObserver *)jarg2;
19147   arg3 = (Dali::CallbackBase *)jarg3;
19148   {
19149     try {
19150       (arg1)->SignalDisconnected(arg2,arg3);
19151     } catch (std::out_of_range& e) {
19152       {
19153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19154       };
19155     } catch (std::exception& e) {
19156       {
19157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19158       };
19159     } catch (Dali::DaliException e) {
19160       {
19161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19162       };
19163     } catch (...) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19166       };
19167     }
19168   }
19169
19170 }
19171
19172
19173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19174   unsigned long jresult ;
19175   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19176   std::size_t result;
19177
19178   arg1 = (Dali::ConnectionTracker *)jarg1;
19179   {
19180     try {
19181       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19182     } catch (std::out_of_range& e) {
19183       {
19184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19185       };
19186     } catch (std::exception& e) {
19187       {
19188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (Dali::DaliException e) {
19191       {
19192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19193       };
19194     } catch (...) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19197       };
19198     }
19199   }
19200
19201   jresult = (unsigned long)result;
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19207   void * jresult ;
19208   Dali::ObjectRegistry *result = 0 ;
19209
19210   {
19211     try {
19212       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19213     } catch (std::out_of_range& e) {
19214       {
19215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19216       };
19217     } catch (std::exception& e) {
19218       {
19219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19220       };
19221     } catch (Dali::DaliException e) {
19222       {
19223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19224       };
19225     } catch (...) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19228       };
19229     }
19230   }
19231
19232   jresult = (void *)result;
19233   return jresult;
19234 }
19235
19236
19237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19238   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19239
19240   arg1 = (Dali::ObjectRegistry *)jarg1;
19241   {
19242     try {
19243       delete arg1;
19244     } catch (std::out_of_range& e) {
19245       {
19246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19247       };
19248     } catch (std::exception& e) {
19249       {
19250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19251       };
19252     } catch (Dali::DaliException e) {
19253       {
19254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19255       };
19256     } catch (...) {
19257       {
19258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19259       };
19260     }
19261   }
19262
19263 }
19264
19265
19266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19267   void * jresult ;
19268   Dali::ObjectRegistry *arg1 = 0 ;
19269   Dali::ObjectRegistry *result = 0 ;
19270
19271   arg1 = (Dali::ObjectRegistry *)jarg1;
19272   if (!arg1) {
19273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19274     return 0;
19275   }
19276   {
19277     try {
19278       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19279     } catch (std::out_of_range& e) {
19280       {
19281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19282       };
19283     } catch (std::exception& e) {
19284       {
19285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19286       };
19287     } catch (Dali::DaliException e) {
19288       {
19289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19290       };
19291     } catch (...) {
19292       {
19293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19294       };
19295     }
19296   }
19297
19298   jresult = (void *)result;
19299   return jresult;
19300 }
19301
19302
19303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19304   void * jresult ;
19305   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19306   Dali::ObjectRegistry *arg2 = 0 ;
19307   Dali::ObjectRegistry *result = 0 ;
19308
19309   arg1 = (Dali::ObjectRegistry *)jarg1;
19310   arg2 = (Dali::ObjectRegistry *)jarg2;
19311   if (!arg2) {
19312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19313     return 0;
19314   }
19315   {
19316     try {
19317       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19318     } catch (std::out_of_range& e) {
19319       {
19320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (std::exception& e) {
19323       {
19324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19325       };
19326     } catch (Dali::DaliException e) {
19327       {
19328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19329       };
19330     } catch (...) {
19331       {
19332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19333       };
19334     }
19335   }
19336
19337   jresult = (void *)result;
19338   return jresult;
19339 }
19340
19341
19342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19343   void * jresult ;
19344   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19345   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19346
19347   arg1 = (Dali::ObjectRegistry *)jarg1;
19348   {
19349     try {
19350       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19351     } catch (std::out_of_range& e) {
19352       {
19353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19354       };
19355     } catch (std::exception& e) {
19356       {
19357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19358       };
19359     } catch (Dali::DaliException e) {
19360       {
19361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19362       };
19363     } catch (...) {
19364       {
19365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19366       };
19367     }
19368   }
19369
19370   jresult = (void *)result;
19371   return jresult;
19372 }
19373
19374
19375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19376   void * jresult ;
19377   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19378   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19379
19380   arg1 = (Dali::ObjectRegistry *)jarg1;
19381   {
19382     try {
19383       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19384     } catch (std::out_of_range& e) {
19385       {
19386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19387       };
19388     } catch (std::exception& e) {
19389       {
19390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19391       };
19392     } catch (Dali::DaliException e) {
19393       {
19394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19395       };
19396     } catch (...) {
19397       {
19398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19399       };
19400     }
19401   }
19402
19403   jresult = (void *)result;
19404   return jresult;
19405 }
19406
19407
19408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19409   void * jresult ;
19410   Dali::PropertyCondition *result = 0 ;
19411
19412   {
19413     try {
19414       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19415     } catch (std::out_of_range& e) {
19416       {
19417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19418       };
19419     } catch (std::exception& e) {
19420       {
19421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19422       };
19423     } catch (Dali::DaliException e) {
19424       {
19425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19426       };
19427     } catch (...) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19430       };
19431     }
19432   }
19433
19434   jresult = (void *)result;
19435   return jresult;
19436 }
19437
19438
19439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19440   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19441
19442   arg1 = (Dali::PropertyCondition *)jarg1;
19443   {
19444     try {
19445       delete arg1;
19446     } catch (std::out_of_range& e) {
19447       {
19448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19449       };
19450     } catch (std::exception& e) {
19451       {
19452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19453       };
19454     } catch (Dali::DaliException e) {
19455       {
19456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19457       };
19458     } catch (...) {
19459       {
19460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19461       };
19462     }
19463   }
19464
19465 }
19466
19467
19468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19469   void * jresult ;
19470   Dali::PropertyCondition *arg1 = 0 ;
19471   Dali::PropertyCondition *result = 0 ;
19472
19473   arg1 = (Dali::PropertyCondition *)jarg1;
19474   if (!arg1) {
19475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19476     return 0;
19477   }
19478   {
19479     try {
19480       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19481     } catch (std::out_of_range& e) {
19482       {
19483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19484       };
19485     } catch (std::exception& e) {
19486       {
19487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19488       };
19489     } catch (Dali::DaliException e) {
19490       {
19491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19492       };
19493     } catch (...) {
19494       {
19495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19496       };
19497     }
19498   }
19499
19500   jresult = (void *)result;
19501   return jresult;
19502 }
19503
19504
19505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19506   void * jresult ;
19507   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19508   Dali::PropertyCondition *arg2 = 0 ;
19509   Dali::PropertyCondition *result = 0 ;
19510
19511   arg1 = (Dali::PropertyCondition *)jarg1;
19512   arg2 = (Dali::PropertyCondition *)jarg2;
19513   if (!arg2) {
19514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19515     return 0;
19516   }
19517   {
19518     try {
19519       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19520     } catch (std::out_of_range& e) {
19521       {
19522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19523       };
19524     } catch (std::exception& e) {
19525       {
19526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19527       };
19528     } catch (Dali::DaliException e) {
19529       {
19530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19531       };
19532     } catch (...) {
19533       {
19534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19535       };
19536     }
19537   }
19538
19539   jresult = (void *)result;
19540   return jresult;
19541 }
19542
19543
19544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19545   unsigned long jresult ;
19546   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19547   std::size_t result;
19548
19549   arg1 = (Dali::PropertyCondition *)jarg1;
19550   {
19551     try {
19552       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19553     } catch (std::out_of_range& e) {
19554       {
19555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19556       };
19557     } catch (std::exception& e) {
19558       {
19559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19560       };
19561     } catch (...) {
19562       {
19563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19564       };
19565     }
19566   }
19567   jresult = (unsigned long)result;
19568   return jresult;
19569 }
19570
19571
19572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19573   float jresult ;
19574   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19575   std::size_t arg2 ;
19576   float result;
19577
19578   arg1 = (Dali::PropertyCondition *)jarg1;
19579   arg2 = (std::size_t)jarg2;
19580   {
19581     try {
19582       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19583     } catch (std::out_of_range& e) {
19584       {
19585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19586       };
19587     } catch (std::exception& e) {
19588       {
19589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19590       };
19591     } catch (...) {
19592       {
19593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19594       };
19595     }
19596   }
19597   jresult = result;
19598   return jresult;
19599 }
19600
19601
19602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19603   void * jresult ;
19604   float arg1 ;
19605   Dali::PropertyCondition result;
19606
19607   arg1 = (float)jarg1;
19608   {
19609     try {
19610       result = Dali::LessThanCondition(arg1);
19611     } catch (std::out_of_range& e) {
19612       {
19613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19614       };
19615     } catch (std::exception& e) {
19616       {
19617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19618       };
19619     } catch (Dali::DaliException e) {
19620       {
19621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19626       };
19627     }
19628   }
19629
19630   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19631   return jresult;
19632 }
19633
19634
19635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19636   void * jresult ;
19637   float arg1 ;
19638   Dali::PropertyCondition result;
19639
19640   arg1 = (float)jarg1;
19641   {
19642     try {
19643       result = Dali::GreaterThanCondition(arg1);
19644     } catch (std::out_of_range& e) {
19645       {
19646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19647       };
19648     } catch (std::exception& e) {
19649       {
19650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19651       };
19652     } catch (Dali::DaliException e) {
19653       {
19654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19655       };
19656     } catch (...) {
19657       {
19658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19659       };
19660     }
19661   }
19662
19663   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19664   return jresult;
19665 }
19666
19667
19668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19669   void * jresult ;
19670   float arg1 ;
19671   float arg2 ;
19672   Dali::PropertyCondition result;
19673
19674   arg1 = (float)jarg1;
19675   arg2 = (float)jarg2;
19676   {
19677     try {
19678       result = Dali::InsideCondition(arg1,arg2);
19679     } catch (std::out_of_range& e) {
19680       {
19681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19682       };
19683     } catch (std::exception& e) {
19684       {
19685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19686       };
19687     } catch (Dali::DaliException e) {
19688       {
19689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19690       };
19691     } catch (...) {
19692       {
19693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19694       };
19695     }
19696   }
19697
19698   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19699   return jresult;
19700 }
19701
19702
19703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19704   void * jresult ;
19705   float arg1 ;
19706   float arg2 ;
19707   Dali::PropertyCondition result;
19708
19709   arg1 = (float)jarg1;
19710   arg2 = (float)jarg2;
19711   {
19712     try {
19713       result = Dali::OutsideCondition(arg1,arg2);
19714     } catch (std::out_of_range& e) {
19715       {
19716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19717       };
19718     } catch (std::exception& e) {
19719       {
19720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19721       };
19722     } catch (Dali::DaliException e) {
19723       {
19724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19725       };
19726     } catch (...) {
19727       {
19728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19729       };
19730     }
19731   }
19732
19733   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19734   return jresult;
19735 }
19736
19737
19738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19739   void * jresult ;
19740   float arg1 ;
19741   float arg2 ;
19742   Dali::PropertyCondition result;
19743
19744   arg1 = (float)jarg1;
19745   arg2 = (float)jarg2;
19746   {
19747     try {
19748       result = Dali::StepCondition(arg1,arg2);
19749     } catch (std::out_of_range& e) {
19750       {
19751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19752       };
19753     } catch (std::exception& e) {
19754       {
19755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19756       };
19757     } catch (Dali::DaliException e) {
19758       {
19759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19760       };
19761     } catch (...) {
19762       {
19763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19764       };
19765     }
19766   }
19767
19768   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19769   return jresult;
19770 }
19771
19772
19773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19774   void * jresult ;
19775   float arg1 ;
19776   Dali::PropertyCondition result;
19777
19778   arg1 = (float)jarg1;
19779   {
19780     try {
19781       result = Dali::StepCondition(arg1);
19782     } catch (std::out_of_range& e) {
19783       {
19784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19785       };
19786     } catch (std::exception& e) {
19787       {
19788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19789       };
19790     } catch (Dali::DaliException e) {
19791       {
19792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19793       };
19794     } catch (...) {
19795       {
19796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19797       };
19798     }
19799   }
19800
19801   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19802   return jresult;
19803 }
19804
19805
19806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19807   void * jresult ;
19808   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19809   Dali::PropertyCondition result;
19810
19811   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19812   if (!arg1) {
19813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19814     return 0;
19815   }
19816   {
19817     try {
19818       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19819     } catch (std::out_of_range& e) {
19820       {
19821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19822       };
19823     } catch (std::exception& e) {
19824       {
19825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19826       };
19827     } catch (Dali::DaliException e) {
19828       {
19829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19830       };
19831     } catch (...) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19834       };
19835     }
19836   }
19837
19838   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19839   return jresult;
19840 }
19841
19842
19843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19844   void * jresult ;
19845   Dali::PropertyNotification *result = 0 ;
19846
19847   {
19848     try {
19849       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19850     } catch (std::out_of_range& e) {
19851       {
19852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19853       };
19854     } catch (std::exception& e) {
19855       {
19856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19857       };
19858     } catch (Dali::DaliException e) {
19859       {
19860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19861       };
19862     } catch (...) {
19863       {
19864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19865       };
19866     }
19867   }
19868
19869   jresult = (void *)result;
19870   return jresult;
19871 }
19872
19873
19874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19875   void * jresult ;
19876   Dali::BaseHandle arg1 ;
19877   Dali::BaseHandle *argp1 ;
19878   Dali::PropertyNotification result;
19879
19880   argp1 = (Dali::BaseHandle *)jarg1;
19881   if (!argp1) {
19882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19883     return 0;
19884   }
19885   arg1 = *argp1;
19886   {
19887     try {
19888       result = Dali::PropertyNotification::DownCast(arg1);
19889     } catch (std::out_of_range& e) {
19890       {
19891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19892       };
19893     } catch (std::exception& e) {
19894       {
19895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19896       };
19897     } catch (Dali::DaliException e) {
19898       {
19899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19900       };
19901     } catch (...) {
19902       {
19903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19904       };
19905     }
19906   }
19907
19908   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19909   return jresult;
19910 }
19911
19912
19913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19914   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19915
19916   arg1 = (Dali::PropertyNotification *)jarg1;
19917   {
19918     try {
19919       delete arg1;
19920     } catch (std::out_of_range& e) {
19921       {
19922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19923       };
19924     } catch (std::exception& e) {
19925       {
19926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19927       };
19928     } catch (Dali::DaliException e) {
19929       {
19930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19931       };
19932     } catch (...) {
19933       {
19934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19935       };
19936     }
19937   }
19938
19939 }
19940
19941
19942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19943   void * jresult ;
19944   Dali::PropertyNotification *arg1 = 0 ;
19945   Dali::PropertyNotification *result = 0 ;
19946
19947   arg1 = (Dali::PropertyNotification *)jarg1;
19948   if (!arg1) {
19949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19950     return 0;
19951   }
19952   {
19953     try {
19954       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19955     } catch (std::out_of_range& e) {
19956       {
19957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19958       };
19959     } catch (std::exception& e) {
19960       {
19961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19962       };
19963     } catch (Dali::DaliException e) {
19964       {
19965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19966       };
19967     } catch (...) {
19968       {
19969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19970       };
19971     }
19972   }
19973
19974   jresult = (void *)result;
19975   return jresult;
19976 }
19977
19978
19979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19980   void * jresult ;
19981   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19982   Dali::PropertyNotification *arg2 = 0 ;
19983   Dali::PropertyNotification *result = 0 ;
19984
19985   arg1 = (Dali::PropertyNotification *)jarg1;
19986   arg2 = (Dali::PropertyNotification *)jarg2;
19987   if (!arg2) {
19988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19989     return 0;
19990   }
19991   {
19992     try {
19993       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19994     } catch (std::out_of_range& e) {
19995       {
19996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19997       };
19998     } catch (std::exception& e) {
19999       {
20000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20001       };
20002     } catch (Dali::DaliException e) {
20003       {
20004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20005       };
20006     } catch (...) {
20007       {
20008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20009       };
20010     }
20011   }
20012
20013   jresult = (void *)result;
20014   return jresult;
20015 }
20016
20017
20018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20019   void * jresult ;
20020   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20021   Dali::PropertyCondition result;
20022
20023   arg1 = (Dali::PropertyNotification *)jarg1;
20024   {
20025     try {
20026       result = (arg1)->GetCondition();
20027     } catch (std::out_of_range& e) {
20028       {
20029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20030       };
20031     } catch (std::exception& e) {
20032       {
20033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20034       };
20035     } catch (Dali::DaliException e) {
20036       {
20037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20038       };
20039     } catch (...) {
20040       {
20041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20042       };
20043     }
20044   }
20045
20046   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20047   return jresult;
20048 }
20049
20050
20051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20052   void * jresult ;
20053   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20054   Dali::Handle result;
20055
20056   arg1 = (Dali::PropertyNotification *)jarg1;
20057   {
20058     try {
20059       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20060     } catch (std::out_of_range& e) {
20061       {
20062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20063       };
20064     } catch (std::exception& e) {
20065       {
20066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20067       };
20068     } catch (Dali::DaliException e) {
20069       {
20070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20071       };
20072     } catch (...) {
20073       {
20074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20075       };
20076     }
20077   }
20078
20079   jresult = new Dali::Handle((const Dali::Handle &)result);
20080   return jresult;
20081 }
20082
20083
20084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20085   int jresult ;
20086   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20087   Dali::Property::Index result;
20088
20089   arg1 = (Dali::PropertyNotification *)jarg1;
20090   {
20091     try {
20092       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20093     } catch (std::out_of_range& e) {
20094       {
20095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20096       };
20097     } catch (std::exception& e) {
20098       {
20099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20100       };
20101     } catch (Dali::DaliException e) {
20102       {
20103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20104       };
20105     } catch (...) {
20106       {
20107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20108       };
20109     }
20110   }
20111
20112   jresult = result;
20113   return jresult;
20114 }
20115
20116
20117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20118   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20119   Dali::PropertyNotification::NotifyMode arg2 ;
20120
20121   arg1 = (Dali::PropertyNotification *)jarg1;
20122   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20123   {
20124     try {
20125       (arg1)->SetNotifyMode(arg2);
20126     } catch (std::out_of_range& e) {
20127       {
20128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20129       };
20130     } catch (std::exception& e) {
20131       {
20132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20133       };
20134     } catch (Dali::DaliException e) {
20135       {
20136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20137       };
20138     } catch (...) {
20139       {
20140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20141       };
20142     }
20143   }
20144
20145 }
20146
20147
20148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20149   int jresult ;
20150   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20151   Dali::PropertyNotification::NotifyMode result;
20152
20153   arg1 = (Dali::PropertyNotification *)jarg1;
20154   {
20155     try {
20156       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20157     } catch (std::out_of_range& e) {
20158       {
20159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20160       };
20161     } catch (std::exception& e) {
20162       {
20163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20164       };
20165     } catch (Dali::DaliException e) {
20166       {
20167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20168       };
20169     } catch (...) {
20170       {
20171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20172       };
20173     }
20174   }
20175
20176   jresult = (int)result;
20177   return jresult;
20178 }
20179
20180
20181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20182   unsigned int jresult ;
20183   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20184   bool result;
20185
20186   arg1 = (Dali::PropertyNotification *)jarg1;
20187   {
20188     try {
20189       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20190     } catch (std::out_of_range& e) {
20191       {
20192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20193       };
20194     } catch (std::exception& e) {
20195       {
20196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20197       };
20198     } catch (Dali::DaliException e) {
20199       {
20200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20201       };
20202     } catch (...) {
20203       {
20204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20205       };
20206     }
20207   }
20208
20209   jresult = result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20215   void * jresult ;
20216   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20217   Dali::PropertyNotifySignalType *result = 0 ;
20218
20219   arg1 = (Dali::PropertyNotification *)jarg1;
20220   {
20221     try {
20222       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20223     } catch (std::out_of_range& e) {
20224       {
20225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20226       };
20227     } catch (std::exception& e) {
20228       {
20229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20230       };
20231     } catch (Dali::DaliException e) {
20232       {
20233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20234       };
20235     } catch (...) {
20236       {
20237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20238       };
20239     }
20240   }
20241
20242   jresult = (void *)result;
20243   return jresult;
20244 }
20245
20246
20247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20248   void * jresult ;
20249   Dali::Handle *result = 0 ;
20250
20251   {
20252     try {
20253       result = (Dali::Handle *)new Dali::Handle();
20254     } catch (std::out_of_range& e) {
20255       {
20256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20257       };
20258     } catch (std::exception& e) {
20259       {
20260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (Dali::DaliException e) {
20263       {
20264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20265       };
20266     } catch (...) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20269       };
20270     }
20271   }
20272
20273   jresult = (void *)result;
20274   return jresult;
20275 }
20276
20277
20278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20279   void * jresult ;
20280   Dali::Handle result;
20281
20282   {
20283     try {
20284       result = Dali::Handle::New();
20285     } catch (std::out_of_range& e) {
20286       {
20287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20288       };
20289     } catch (std::exception& e) {
20290       {
20291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20292       };
20293     } catch (Dali::DaliException e) {
20294       {
20295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20296       };
20297     } catch (...) {
20298       {
20299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20300       };
20301     }
20302   }
20303
20304   jresult = new Dali::Handle((const Dali::Handle &)result);
20305   return jresult;
20306 }
20307
20308
20309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20310   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20311
20312   arg1 = (Dali::Handle *)jarg1;
20313   {
20314     try {
20315       delete arg1;
20316     } catch (std::out_of_range& e) {
20317       {
20318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20319       };
20320     } catch (std::exception& e) {
20321       {
20322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20323       };
20324     } catch (Dali::DaliException e) {
20325       {
20326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20327       };
20328     } catch (...) {
20329       {
20330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20331       };
20332     }
20333   }
20334
20335 }
20336
20337
20338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20339   void * jresult ;
20340   Dali::Handle *arg1 = 0 ;
20341   Dali::Handle *result = 0 ;
20342
20343   arg1 = (Dali::Handle *)jarg1;
20344   if (!arg1) {
20345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20346     return 0;
20347   }
20348   {
20349     try {
20350       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20351     } catch (std::out_of_range& e) {
20352       {
20353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20354       };
20355     } catch (std::exception& e) {
20356       {
20357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20358       };
20359     } catch (Dali::DaliException e) {
20360       {
20361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20362       };
20363     } catch (...) {
20364       {
20365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20366       };
20367     }
20368   }
20369
20370   jresult = (void *)result;
20371   return jresult;
20372 }
20373
20374
20375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20376   void * jresult ;
20377   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20378   Dali::Handle *arg2 = 0 ;
20379   Dali::Handle *result = 0 ;
20380
20381   arg1 = (Dali::Handle *)jarg1;
20382   arg2 = (Dali::Handle *)jarg2;
20383   if (!arg2) {
20384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20385     return 0;
20386   }
20387   {
20388     try {
20389       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20390     } catch (std::out_of_range& e) {
20391       {
20392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20393       };
20394     } catch (std::exception& e) {
20395       {
20396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20397       };
20398     } catch (Dali::DaliException e) {
20399       {
20400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20401       };
20402     } catch (...) {
20403       {
20404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20405       };
20406     }
20407   }
20408
20409   jresult = (void *)result;
20410   return jresult;
20411 }
20412
20413
20414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20415   void * jresult ;
20416   Dali::BaseHandle arg1 ;
20417   Dali::BaseHandle *argp1 ;
20418   Dali::Handle result;
20419
20420   argp1 = (Dali::BaseHandle *)jarg1;
20421   if (!argp1) {
20422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20423     return 0;
20424   }
20425   arg1 = *argp1;
20426   {
20427     try {
20428       result = Dali::Handle::DownCast(arg1);
20429     } catch (std::out_of_range& e) {
20430       {
20431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20432       };
20433     } catch (std::exception& e) {
20434       {
20435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20436       };
20437     } catch (Dali::DaliException e) {
20438       {
20439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20440       };
20441     } catch (...) {
20442       {
20443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20444       };
20445     }
20446   }
20447
20448   jresult = new Dali::Handle((const Dali::Handle &)result);
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20454   unsigned int jresult ;
20455   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20456   Dali::Handle::Capability arg2 ;
20457   bool result;
20458
20459   arg1 = (Dali::Handle *)jarg1;
20460   arg2 = (Dali::Handle::Capability)jarg2;
20461   {
20462     try {
20463       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20464     } catch (std::out_of_range& e) {
20465       {
20466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20467       };
20468     } catch (std::exception& e) {
20469       {
20470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20471       };
20472     } catch (Dali::DaliException e) {
20473       {
20474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20475       };
20476     } catch (...) {
20477       {
20478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20479       };
20480     }
20481   }
20482
20483   jresult = result;
20484   return jresult;
20485 }
20486
20487
20488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20489   unsigned int jresult ;
20490   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20491   unsigned int result;
20492
20493   arg1 = (Dali::Handle *)jarg1;
20494   {
20495     try {
20496       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20497     } catch (std::out_of_range& e) {
20498       {
20499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20500       };
20501     } catch (std::exception& e) {
20502       {
20503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20504       };
20505     } catch (Dali::DaliException e) {
20506       {
20507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20508       };
20509     } catch (...) {
20510       {
20511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20512       };
20513     }
20514   }
20515
20516   jresult = result;
20517   return jresult;
20518 }
20519
20520
20521 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20522   char * jresult ;
20523   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20524   Dali::Property::Index arg2 ;
20525   std::string result;
20526
20527   arg1 = (Dali::Handle *)jarg1;
20528   arg2 = (Dali::Property::Index)jarg2;
20529   {
20530     try {
20531       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20532     } catch (std::out_of_range& e) {
20533       {
20534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20535       };
20536     } catch (std::exception& e) {
20537       {
20538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20539       };
20540     } catch (Dali::DaliException e) {
20541       {
20542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20543       };
20544     } catch (...) {
20545       {
20546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20547       };
20548     }
20549   }
20550
20551   jresult = SWIG_csharp_string_callback((&result)->c_str());
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20557   int jresult ;
20558   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20559   std::string *arg2 = 0 ;
20560   Dali::Property::Index result;
20561
20562   arg1 = (Dali::Handle *)jarg1;
20563   if (!jarg2) {
20564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20565     return 0;
20566   }
20567   std::string arg2_str(jarg2);
20568   arg2 = &arg2_str;
20569   {
20570     try {
20571       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20572     } catch (std::out_of_range& e) {
20573       {
20574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20575       };
20576     } catch (std::exception& e) {
20577       {
20578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20579       };
20580     } catch (Dali::DaliException e) {
20581       {
20582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20583       };
20584     } catch (...) {
20585       {
20586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20587       };
20588     }
20589   }
20590
20591   jresult = result;
20592
20593   //argout typemap for const std::string&
20594
20595   return jresult;
20596 }
20597
20598
20599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20600   unsigned int jresult ;
20601   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20602   Dali::Property::Index arg2 ;
20603   bool result;
20604
20605   arg1 = (Dali::Handle *)jarg1;
20606   arg2 = (Dali::Property::Index)jarg2;
20607   {
20608     try {
20609       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20610     } catch (std::out_of_range& e) {
20611       {
20612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20613       };
20614     } catch (std::exception& e) {
20615       {
20616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20617       };
20618     } catch (Dali::DaliException e) {
20619       {
20620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20621       };
20622     } catch (...) {
20623       {
20624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20625       };
20626     }
20627   }
20628
20629   jresult = result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20635   unsigned int jresult ;
20636   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20637   Dali::Property::Index arg2 ;
20638   bool result;
20639
20640   arg1 = (Dali::Handle *)jarg1;
20641   arg2 = (Dali::Property::Index)jarg2;
20642   {
20643     try {
20644       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (Dali::DaliException e) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20656       };
20657     } catch (...) {
20658       {
20659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20660       };
20661     }
20662   }
20663
20664   jresult = result;
20665   return jresult;
20666 }
20667
20668
20669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20670   unsigned int jresult ;
20671   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20672   Dali::Property::Index arg2 ;
20673   bool result;
20674
20675   arg1 = (Dali::Handle *)jarg1;
20676   arg2 = (Dali::Property::Index)jarg2;
20677   {
20678     try {
20679       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20680     } catch (std::out_of_range& e) {
20681       {
20682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20683       };
20684     } catch (std::exception& e) {
20685       {
20686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20687       };
20688     } catch (Dali::DaliException e) {
20689       {
20690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20691       };
20692     } catch (...) {
20693       {
20694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20695       };
20696     }
20697   }
20698
20699   jresult = result;
20700   return jresult;
20701 }
20702
20703
20704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20705   int jresult ;
20706   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20707   Dali::Property::Index arg2 ;
20708   Dali::Property::Type result;
20709
20710   arg1 = (Dali::Handle *)jarg1;
20711   arg2 = (Dali::Property::Index)jarg2;
20712   {
20713     try {
20714       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20715     } catch (std::out_of_range& e) {
20716       {
20717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20718       };
20719     } catch (std::exception& e) {
20720       {
20721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20722       };
20723     } catch (Dali::DaliException e) {
20724       {
20725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20726       };
20727     } catch (...) {
20728       {
20729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20730       };
20731     }
20732   }
20733
20734   jresult = (int)result;
20735   return jresult;
20736 }
20737
20738
20739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20740   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20741   Dali::Property::Index arg2 ;
20742   Dali::Property::Value *arg3 = 0 ;
20743
20744   arg1 = (Dali::Handle *)jarg1;
20745   arg2 = (Dali::Property::Index)jarg2;
20746   arg3 = (Dali::Property::Value *)jarg3;
20747   if (!arg3) {
20748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20749     return ;
20750   }
20751   {
20752     try {
20753       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20754     } catch (std::out_of_range& e) {
20755       {
20756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20757       };
20758     } catch (std::exception& e) {
20759       {
20760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20761       };
20762     } catch (Dali::DaliException e) {
20763       {
20764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20765       };
20766     } catch (...) {
20767       {
20768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20769       };
20770     }
20771   }
20772
20773 }
20774
20775
20776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20777   int jresult ;
20778   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20779   std::string *arg2 = 0 ;
20780   Dali::Property::Value *arg3 = 0 ;
20781   Dali::Property::Index result;
20782
20783   arg1 = (Dali::Handle *)jarg1;
20784   if (!jarg2) {
20785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20786     return 0;
20787   }
20788   std::string arg2_str(jarg2);
20789   arg2 = &arg2_str;
20790   arg3 = (Dali::Property::Value *)jarg3;
20791   if (!arg3) {
20792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20793     return 0;
20794   }
20795   {
20796     try {
20797       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20798     } catch (std::out_of_range& e) {
20799       {
20800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20801       };
20802     } catch (std::exception& e) {
20803       {
20804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20805       };
20806     } catch (Dali::DaliException e) {
20807       {
20808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20809       };
20810     } catch (...) {
20811       {
20812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20813       };
20814     }
20815   }
20816
20817   jresult = result;
20818
20819   //argout typemap for const std::string&
20820
20821   return jresult;
20822 }
20823
20824
20825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20826   int jresult ;
20827   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20828   std::string *arg2 = 0 ;
20829   Dali::Property::Value *arg3 = 0 ;
20830   Dali::Property::AccessMode arg4 ;
20831   Dali::Property::Index result;
20832
20833   arg1 = (Dali::Handle *)jarg1;
20834   if (!jarg2) {
20835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20836     return 0;
20837   }
20838   std::string arg2_str(jarg2);
20839   arg2 = &arg2_str;
20840   arg3 = (Dali::Property::Value *)jarg3;
20841   if (!arg3) {
20842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20843     return 0;
20844   }
20845   arg4 = (Dali::Property::AccessMode)jarg4;
20846   {
20847     try {
20848       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20849     } catch (std::out_of_range& e) {
20850       {
20851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20852       };
20853     } catch (std::exception& e) {
20854       {
20855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20856       };
20857     } catch (Dali::DaliException e) {
20858       {
20859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20860       };
20861     } catch (...) {
20862       {
20863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20864       };
20865     }
20866   }
20867
20868   jresult = result;
20869
20870   //argout typemap for const std::string&
20871
20872   return jresult;
20873 }
20874
20875
20876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20877   void * jresult ;
20878   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20879   Dali::Property::Index arg2 ;
20880   Dali::Property::Value result;
20881
20882   arg1 = (Dali::Handle *)jarg1;
20883   arg2 = (Dali::Property::Index)jarg2;
20884   {
20885     try {
20886       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20887     } catch (std::out_of_range& e) {
20888       {
20889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20890       };
20891     } catch (std::exception& e) {
20892       {
20893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20894       };
20895     } catch (Dali::DaliException e) {
20896       {
20897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20898       };
20899     } catch (...) {
20900       {
20901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20902       };
20903     }
20904   }
20905
20906   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20907   return jresult;
20908 }
20909
20910
20911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20912   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20913   Dali::Property::IndexContainer *arg2 = 0 ;
20914
20915   arg1 = (Dali::Handle *)jarg1;
20916   arg2 = (Dali::Property::IndexContainer *)jarg2;
20917   if (!arg2) {
20918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20919     return ;
20920   }
20921   {
20922     try {
20923       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20924     } catch (std::out_of_range& e) {
20925       {
20926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20927       };
20928     } catch (std::exception& e) {
20929       {
20930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20931       };
20932     } catch (Dali::DaliException e) {
20933       {
20934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20935       };
20936     } catch (...) {
20937       {
20938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20939       };
20940     }
20941   }
20942
20943 }
20944
20945
20946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20947   void * jresult ;
20948   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20949   Dali::Property::Index arg2 ;
20950   Dali::PropertyCondition *arg3 = 0 ;
20951   Dali::PropertyNotification result;
20952
20953   arg1 = (Dali::Handle *)jarg1;
20954   arg2 = (Dali::Property::Index)jarg2;
20955   arg3 = (Dali::PropertyCondition *)jarg3;
20956   if (!arg3) {
20957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20958     return 0;
20959   }
20960   {
20961     try {
20962       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20963     } catch (std::out_of_range& e) {
20964       {
20965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20966       };
20967     } catch (std::exception& e) {
20968       {
20969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20970       };
20971     } catch (Dali::DaliException e) {
20972       {
20973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20974       };
20975     } catch (...) {
20976       {
20977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20978       };
20979     }
20980   }
20981
20982   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20983   return jresult;
20984 }
20985
20986
20987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20988   void * jresult ;
20989   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20990   Dali::Property::Index arg2 ;
20991   int arg3 ;
20992   Dali::PropertyCondition *arg4 = 0 ;
20993   Dali::PropertyNotification result;
20994
20995   arg1 = (Dali::Handle *)jarg1;
20996   arg2 = (Dali::Property::Index)jarg2;
20997   arg3 = (int)jarg3;
20998   arg4 = (Dali::PropertyCondition *)jarg4;
20999   if (!arg4) {
21000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21001     return 0;
21002   }
21003   {
21004     try {
21005       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21006     } catch (std::out_of_range& e) {
21007       {
21008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21009       };
21010     } catch (std::exception& e) {
21011       {
21012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21013       };
21014     } catch (Dali::DaliException e) {
21015       {
21016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21017       };
21018     } catch (...) {
21019       {
21020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21021       };
21022     }
21023   }
21024
21025   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21026   return jresult;
21027 }
21028
21029
21030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21031   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21032   Dali::PropertyNotification arg2 ;
21033   Dali::PropertyNotification *argp2 ;
21034
21035   arg1 = (Dali::Handle *)jarg1;
21036   argp2 = (Dali::PropertyNotification *)jarg2;
21037   if (!argp2) {
21038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21039     return ;
21040   }
21041   arg2 = *argp2;
21042   {
21043     try {
21044       (arg1)->RemovePropertyNotification(arg2);
21045     } catch (std::out_of_range& e) {
21046       {
21047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21048       };
21049     } catch (std::exception& e) {
21050       {
21051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21052       };
21053     } catch (Dali::DaliException e) {
21054       {
21055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21056       };
21057     } catch (...) {
21058       {
21059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21060       };
21061     }
21062   }
21063
21064 }
21065
21066
21067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21068   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21069
21070   arg1 = (Dali::Handle *)jarg1;
21071   {
21072     try {
21073       (arg1)->RemovePropertyNotifications();
21074     } catch (std::out_of_range& e) {
21075       {
21076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21077       };
21078     } catch (std::exception& e) {
21079       {
21080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21081       };
21082     } catch (Dali::DaliException e) {
21083       {
21084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21085       };
21086     } catch (...) {
21087       {
21088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21089       };
21090     }
21091   }
21092
21093 }
21094
21095
21096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21097   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21098
21099   arg1 = (Dali::Handle *)jarg1;
21100   {
21101     try {
21102       (arg1)->RemoveConstraints();
21103     } catch (std::out_of_range& e) {
21104       {
21105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21106       };
21107     } catch (std::exception& e) {
21108       {
21109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21110       };
21111     } catch (Dali::DaliException e) {
21112       {
21113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21114       };
21115     } catch (...) {
21116       {
21117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21118       };
21119     }
21120   }
21121
21122 }
21123
21124
21125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21126   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21127   unsigned int arg2 ;
21128
21129   arg1 = (Dali::Handle *)jarg1;
21130   arg2 = (unsigned int)jarg2;
21131   {
21132     try {
21133       (arg1)->RemoveConstraints(arg2);
21134     } catch (std::out_of_range& e) {
21135       {
21136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21137       };
21138     } catch (std::exception& e) {
21139       {
21140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21141       };
21142     } catch (Dali::DaliException e) {
21143       {
21144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21145       };
21146     } catch (...) {
21147       {
21148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21149       };
21150     }
21151   }
21152
21153 }
21154
21155
21156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21157   int jresult ;
21158   Dali::Property::Index result;
21159
21160   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21161   jresult = result;
21162   return jresult;
21163 }
21164
21165
21166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21167   void * jresult ;
21168   Dali::Handle result;
21169
21170   {
21171     try {
21172       result = Dali::WeightObject::New();
21173     } catch (std::out_of_range& e) {
21174       {
21175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21176       };
21177     } catch (std::exception& e) {
21178       {
21179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21180       };
21181     } catch (Dali::DaliException e) {
21182       {
21183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21184       };
21185     } catch (...) {
21186       {
21187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21188       };
21189     }
21190   }
21191
21192   jresult = new Dali::Handle((const Dali::Handle &)result);
21193   return jresult;
21194 }
21195
21196
21197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21198   void * jresult ;
21199   Dali::TypeInfo *result = 0 ;
21200
21201   {
21202     try {
21203       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21204     } catch (std::out_of_range& e) {
21205       {
21206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21207       };
21208     } catch (std::exception& e) {
21209       {
21210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21211       };
21212     } catch (Dali::DaliException e) {
21213       {
21214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21215       };
21216     } catch (...) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21219       };
21220     }
21221   }
21222
21223   jresult = (void *)result;
21224   return jresult;
21225 }
21226
21227
21228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21229   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21230
21231   arg1 = (Dali::TypeInfo *)jarg1;
21232   {
21233     try {
21234       delete arg1;
21235     } catch (std::out_of_range& e) {
21236       {
21237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21238       };
21239     } catch (std::exception& e) {
21240       {
21241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21242       };
21243     } catch (Dali::DaliException e) {
21244       {
21245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21246       };
21247     } catch (...) {
21248       {
21249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21250       };
21251     }
21252   }
21253
21254 }
21255
21256
21257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21258   void * jresult ;
21259   Dali::TypeInfo *arg1 = 0 ;
21260   Dali::TypeInfo *result = 0 ;
21261
21262   arg1 = (Dali::TypeInfo *)jarg1;
21263   if (!arg1) {
21264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21265     return 0;
21266   }
21267   {
21268     try {
21269       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21270     } catch (std::out_of_range& e) {
21271       {
21272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21273       };
21274     } catch (std::exception& e) {
21275       {
21276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21277       };
21278     } catch (Dali::DaliException e) {
21279       {
21280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21281       };
21282     } catch (...) {
21283       {
21284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21285       };
21286     }
21287   }
21288
21289   jresult = (void *)result;
21290   return jresult;
21291 }
21292
21293
21294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21295   void * jresult ;
21296   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21297   Dali::TypeInfo *arg2 = 0 ;
21298   Dali::TypeInfo *result = 0 ;
21299
21300   arg1 = (Dali::TypeInfo *)jarg1;
21301   arg2 = (Dali::TypeInfo *)jarg2;
21302   if (!arg2) {
21303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21304     return 0;
21305   }
21306   {
21307     try {
21308       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21309     } catch (std::out_of_range& e) {
21310       {
21311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21312       };
21313     } catch (std::exception& e) {
21314       {
21315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21316       };
21317     } catch (Dali::DaliException e) {
21318       {
21319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21320       };
21321     } catch (...) {
21322       {
21323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21324       };
21325     }
21326   }
21327
21328   jresult = (void *)result;
21329   return jresult;
21330 }
21331
21332
21333 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21334   char * jresult ;
21335   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21336   std::string *result = 0 ;
21337
21338   arg1 = (Dali::TypeInfo *)jarg1;
21339   {
21340     try {
21341       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21342     } catch (std::out_of_range& e) {
21343       {
21344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21345       };
21346     } catch (std::exception& e) {
21347       {
21348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21349       };
21350     } catch (Dali::DaliException e) {
21351       {
21352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21353       };
21354     } catch (...) {
21355       {
21356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21357       };
21358     }
21359   }
21360
21361   jresult = SWIG_csharp_string_callback(result->c_str());
21362   return jresult;
21363 }
21364
21365
21366 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21367   char * jresult ;
21368   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21369   std::string *result = 0 ;
21370
21371   arg1 = (Dali::TypeInfo *)jarg1;
21372   {
21373     try {
21374       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21375     } catch (std::out_of_range& e) {
21376       {
21377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21378       };
21379     } catch (std::exception& e) {
21380       {
21381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21382       };
21383     } catch (Dali::DaliException e) {
21384       {
21385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21386       };
21387     } catch (...) {
21388       {
21389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21390       };
21391     }
21392   }
21393
21394   jresult = SWIG_csharp_string_callback(result->c_str());
21395   return jresult;
21396 }
21397
21398
21399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21400   void * jresult ;
21401   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21402   Dali::BaseHandle result;
21403
21404   arg1 = (Dali::TypeInfo *)jarg1;
21405   {
21406     try {
21407       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21408     } catch (std::out_of_range& e) {
21409       {
21410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21411       };
21412     } catch (std::exception& e) {
21413       {
21414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21415       };
21416     } catch (Dali::DaliException e) {
21417       {
21418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21419       };
21420     } catch (...) {
21421       {
21422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21423       };
21424     }
21425   }
21426
21427   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21428   return jresult;
21429 }
21430
21431
21432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21433   unsigned long jresult ;
21434   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21435   size_t result;
21436
21437   arg1 = (Dali::TypeInfo *)jarg1;
21438   {
21439     try {
21440       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21441     } catch (std::out_of_range& e) {
21442       {
21443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21444       };
21445     } catch (std::exception& e) {
21446       {
21447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21448       };
21449     } catch (Dali::DaliException e) {
21450       {
21451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21452       };
21453     } catch (...) {
21454       {
21455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21456       };
21457     }
21458   }
21459
21460   jresult = (unsigned long)result;
21461   return jresult;
21462 }
21463
21464
21465 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21466   char * jresult ;
21467   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21468   size_t arg2 ;
21469   std::string result;
21470
21471   arg1 = (Dali::TypeInfo *)jarg1;
21472   arg2 = (size_t)jarg2;
21473   {
21474     try {
21475       result = (arg1)->GetActionName(arg2);
21476     } catch (std::out_of_range& e) {
21477       {
21478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21479       };
21480     } catch (std::exception& e) {
21481       {
21482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21483       };
21484     } catch (Dali::DaliException e) {
21485       {
21486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21487       };
21488     } catch (...) {
21489       {
21490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21491       };
21492     }
21493   }
21494
21495   jresult = SWIG_csharp_string_callback((&result)->c_str());
21496   return jresult;
21497 }
21498
21499
21500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21501   unsigned long jresult ;
21502   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21503   size_t result;
21504
21505   arg1 = (Dali::TypeInfo *)jarg1;
21506   {
21507     try {
21508       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21509     } catch (std::out_of_range& e) {
21510       {
21511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21512       };
21513     } catch (std::exception& e) {
21514       {
21515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21516       };
21517     } catch (Dali::DaliException e) {
21518       {
21519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21520       };
21521     } catch (...) {
21522       {
21523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21524       };
21525     }
21526   }
21527
21528   jresult = (unsigned long)result;
21529   return jresult;
21530 }
21531
21532
21533 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21534   char * jresult ;
21535   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21536   size_t arg2 ;
21537   std::string result;
21538
21539   arg1 = (Dali::TypeInfo *)jarg1;
21540   arg2 = (size_t)jarg2;
21541   {
21542     try {
21543       result = (arg1)->GetSignalName(arg2);
21544     } catch (std::out_of_range& e) {
21545       {
21546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21547       };
21548     } catch (std::exception& e) {
21549       {
21550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (Dali::DaliException e) {
21553       {
21554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21555       };
21556     } catch (...) {
21557       {
21558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21559       };
21560     }
21561   }
21562
21563   jresult = SWIG_csharp_string_callback((&result)->c_str());
21564   return jresult;
21565 }
21566
21567
21568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21569   unsigned long jresult ;
21570   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21571   size_t result;
21572
21573   arg1 = (Dali::TypeInfo *)jarg1;
21574   {
21575     try {
21576       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21577     } catch (std::out_of_range& e) {
21578       {
21579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21580       };
21581     } catch (std::exception& e) {
21582       {
21583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21584       };
21585     } catch (Dali::DaliException e) {
21586       {
21587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21588       };
21589     } catch (...) {
21590       {
21591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21592       };
21593     }
21594   }
21595
21596   jresult = (unsigned long)result;
21597   return jresult;
21598 }
21599
21600
21601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21602   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21603   Dali::Property::IndexContainer *arg2 = 0 ;
21604
21605   arg1 = (Dali::TypeInfo *)jarg1;
21606   arg2 = (Dali::Property::IndexContainer *)jarg2;
21607   if (!arg2) {
21608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21609     return ;
21610   }
21611   {
21612     try {
21613       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21614     } catch (std::out_of_range& e) {
21615       {
21616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21617       };
21618     } catch (std::exception& e) {
21619       {
21620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21621       };
21622     } catch (Dali::DaliException e) {
21623       {
21624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21625       };
21626     } catch (...) {
21627       {
21628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21629       };
21630     }
21631   }
21632
21633 }
21634
21635
21636 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21637   char * jresult ;
21638   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21639   Dali::Property::Index arg2 ;
21640   std::string *result = 0 ;
21641
21642   arg1 = (Dali::TypeInfo *)jarg1;
21643   arg2 = (Dali::Property::Index)jarg2;
21644   {
21645     try {
21646       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21647     } catch (std::out_of_range& e) {
21648       {
21649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21650       };
21651     } catch (std::exception& e) {
21652       {
21653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (Dali::DaliException e) {
21656       {
21657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21658       };
21659     } catch (...) {
21660       {
21661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21662       };
21663     }
21664   }
21665
21666   jresult = SWIG_csharp_string_callback(result->c_str());
21667   return jresult;
21668 }
21669
21670
21671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21672   void * jresult ;
21673   Dali::TypeRegistry result;
21674
21675   {
21676     try {
21677       result = Dali::TypeRegistry::Get();
21678     } catch (std::out_of_range& e) {
21679       {
21680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21681       };
21682     } catch (std::exception& e) {
21683       {
21684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21685       };
21686     } catch (Dali::DaliException e) {
21687       {
21688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21689       };
21690     } catch (...) {
21691       {
21692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21693       };
21694     }
21695   }
21696
21697   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21698   return jresult;
21699 }
21700
21701
21702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21703   void * jresult ;
21704   Dali::TypeRegistry *result = 0 ;
21705
21706   {
21707     try {
21708       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21709     } catch (std::out_of_range& e) {
21710       {
21711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21712       };
21713     } catch (std::exception& e) {
21714       {
21715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21716       };
21717     } catch (Dali::DaliException e) {
21718       {
21719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21720       };
21721     } catch (...) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21724       };
21725     }
21726   }
21727
21728   jresult = (void *)result;
21729   return jresult;
21730 }
21731
21732
21733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21734   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21735
21736   arg1 = (Dali::TypeRegistry *)jarg1;
21737   {
21738     try {
21739       delete arg1;
21740     } catch (std::out_of_range& e) {
21741       {
21742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21743       };
21744     } catch (std::exception& e) {
21745       {
21746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21747       };
21748     } catch (Dali::DaliException e) {
21749       {
21750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21751       };
21752     } catch (...) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21755       };
21756     }
21757   }
21758
21759 }
21760
21761
21762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21763   void * jresult ;
21764   Dali::TypeRegistry *arg1 = 0 ;
21765   Dali::TypeRegistry *result = 0 ;
21766
21767   arg1 = (Dali::TypeRegistry *)jarg1;
21768   if (!arg1) {
21769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21770     return 0;
21771   }
21772   {
21773     try {
21774       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21775     } catch (std::out_of_range& e) {
21776       {
21777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (std::exception& e) {
21780       {
21781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (Dali::DaliException e) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21790       };
21791     }
21792   }
21793
21794   jresult = (void *)result;
21795   return jresult;
21796 }
21797
21798
21799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21800   void * jresult ;
21801   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21802   Dali::TypeRegistry *arg2 = 0 ;
21803   Dali::TypeRegistry *result = 0 ;
21804
21805   arg1 = (Dali::TypeRegistry *)jarg1;
21806   arg2 = (Dali::TypeRegistry *)jarg2;
21807   if (!arg2) {
21808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21809     return 0;
21810   }
21811   {
21812     try {
21813       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21814     } catch (std::out_of_range& e) {
21815       {
21816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21817       };
21818     } catch (std::exception& e) {
21819       {
21820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21821       };
21822     } catch (Dali::DaliException e) {
21823       {
21824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21825       };
21826     } catch (...) {
21827       {
21828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21829       };
21830     }
21831   }
21832
21833   jresult = (void *)result;
21834   return jresult;
21835 }
21836
21837
21838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21839   void * jresult ;
21840   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21841   std::string *arg2 = 0 ;
21842   Dali::TypeInfo result;
21843
21844   arg1 = (Dali::TypeRegistry *)jarg1;
21845   if (!jarg2) {
21846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21847     return 0;
21848   }
21849   std::string arg2_str(jarg2);
21850   arg2 = &arg2_str;
21851   {
21852     try {
21853       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21854     } catch (std::out_of_range& e) {
21855       {
21856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21857       };
21858     } catch (std::exception& e) {
21859       {
21860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21861       };
21862     } catch (Dali::DaliException e) {
21863       {
21864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21865       };
21866     } catch (...) {
21867       {
21868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21869       };
21870     }
21871   }
21872
21873   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21874
21875   //argout typemap for const std::string&
21876
21877   return jresult;
21878 }
21879
21880
21881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21882   void * jresult ;
21883   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21884   std::type_info *arg2 = 0 ;
21885   Dali::TypeInfo result;
21886
21887   arg1 = (Dali::TypeRegistry *)jarg1;
21888   arg2 = (std::type_info *)jarg2;
21889   if (!arg2) {
21890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21891     return 0;
21892   }
21893   {
21894     try {
21895       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21896     } catch (std::out_of_range& e) {
21897       {
21898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21899       };
21900     } catch (std::exception& e) {
21901       {
21902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21903       };
21904     } catch (Dali::DaliException e) {
21905       {
21906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21907       };
21908     } catch (...) {
21909       {
21910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21911       };
21912     }
21913   }
21914
21915   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21916   return jresult;
21917 }
21918
21919
21920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21921   unsigned long jresult ;
21922   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21923   size_t result;
21924
21925   arg1 = (Dali::TypeRegistry *)jarg1;
21926   {
21927     try {
21928       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
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 (Dali::DaliException e) {
21938       {
21939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21940       };
21941     } catch (...) {
21942       {
21943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21944       };
21945     }
21946   }
21947
21948   jresult = (unsigned long)result;
21949   return jresult;
21950 }
21951
21952
21953 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21954   char * jresult ;
21955   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21956   size_t arg2 ;
21957   std::string result;
21958
21959   arg1 = (Dali::TypeRegistry *)jarg1;
21960   arg2 = (size_t)jarg2;
21961   {
21962     try {
21963       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21964     } catch (std::out_of_range& e) {
21965       {
21966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21967       };
21968     } catch (std::exception& e) {
21969       {
21970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21971       };
21972     } catch (Dali::DaliException e) {
21973       {
21974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21975       };
21976     } catch (...) {
21977       {
21978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21979       };
21980     }
21981   }
21982
21983   jresult = SWIG_csharp_string_callback((&result)->c_str());
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21989   void * jresult ;
21990   std::type_info *arg1 = 0 ;
21991   std::type_info *arg2 = 0 ;
21992   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21993   Dali::TypeRegistration *result = 0 ;
21994
21995   arg1 = (std::type_info *)jarg1;
21996   if (!arg1) {
21997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21998     return 0;
21999   }
22000   arg2 = (std::type_info *)jarg2;
22001   if (!arg2) {
22002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22003     return 0;
22004   }
22005   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22006   {
22007     try {
22008       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22009     } catch (std::out_of_range& e) {
22010       {
22011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22012       };
22013     } catch (std::exception& e) {
22014       {
22015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22016       };
22017     } catch (Dali::DaliException e) {
22018       {
22019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22024       };
22025     }
22026   }
22027
22028   jresult = (void *)result;
22029   return jresult;
22030 }
22031
22032
22033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22034   void * jresult ;
22035   std::type_info *arg1 = 0 ;
22036   std::type_info *arg2 = 0 ;
22037   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22038   bool arg4 ;
22039   Dali::TypeRegistration *result = 0 ;
22040
22041   arg1 = (std::type_info *)jarg1;
22042   if (!arg1) {
22043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22044     return 0;
22045   }
22046   arg2 = (std::type_info *)jarg2;
22047   if (!arg2) {
22048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22049     return 0;
22050   }
22051   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22052   arg4 = jarg4 ? true : false;
22053   {
22054     try {
22055       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22056     } catch (std::out_of_range& e) {
22057       {
22058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22059       };
22060     } catch (std::exception& e) {
22061       {
22062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22063       };
22064     } catch (Dali::DaliException e) {
22065       {
22066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22067       };
22068     } catch (...) {
22069       {
22070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22071       };
22072     }
22073   }
22074
22075   jresult = (void *)result;
22076   return jresult;
22077 }
22078
22079
22080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22081   void * jresult ;
22082   std::string *arg1 = 0 ;
22083   std::type_info *arg2 = 0 ;
22084   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22085   Dali::TypeRegistration *result = 0 ;
22086
22087   if (!jarg1) {
22088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22089     return 0;
22090   }
22091   std::string arg1_str(jarg1);
22092   arg1 = &arg1_str;
22093   arg2 = (std::type_info *)jarg2;
22094   if (!arg2) {
22095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22096     return 0;
22097   }
22098   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22099   {
22100     try {
22101       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22102     } catch (std::out_of_range& e) {
22103       {
22104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22105       };
22106     } catch (std::exception& e) {
22107       {
22108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22109       };
22110     } catch (Dali::DaliException e) {
22111       {
22112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22113       };
22114     } catch (...) {
22115       {
22116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22117       };
22118     }
22119   }
22120
22121   jresult = (void *)result;
22122
22123   //argout typemap for const std::string&
22124
22125   return jresult;
22126 }
22127
22128
22129 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22130   char * jresult ;
22131   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22132   std::string result;
22133
22134   arg1 = (Dali::TypeRegistration *)jarg1;
22135   {
22136     try {
22137       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22138     } catch (std::out_of_range& e) {
22139       {
22140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22141       };
22142     } catch (std::exception& e) {
22143       {
22144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22145       };
22146     } catch (Dali::DaliException e) {
22147       {
22148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22149       };
22150     } catch (...) {
22151       {
22152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22153       };
22154     }
22155   }
22156
22157   jresult = SWIG_csharp_string_callback((&result)->c_str());
22158   return jresult;
22159 }
22160
22161
22162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22163   std::string *arg1 = 0 ;
22164   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22165
22166   if (!jarg1) {
22167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22168     return ;
22169   }
22170   std::string arg1_str(jarg1);
22171   arg1 = &arg1_str;
22172   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22173   {
22174     try {
22175       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22176     } catch (std::out_of_range& e) {
22177       {
22178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22179       };
22180     } catch (std::exception& e) {
22181       {
22182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22183       };
22184     } catch (Dali::DaliException e) {
22185       {
22186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22187       };
22188     } catch (...) {
22189       {
22190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22191       };
22192     }
22193   }
22194
22195
22196   //argout typemap for const std::string&
22197
22198 }
22199
22200
22201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22202   std::string *arg1 = 0 ;
22203   std::string *arg2 = 0 ;
22204   int arg3 ;
22205   Dali::Property::Type arg4 ;
22206   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22207   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22208
22209   if (!jarg1) {
22210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22211     return ;
22212   }
22213   std::string arg1_str(jarg1);
22214   arg1 = &arg1_str;
22215   if (!jarg2) {
22216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22217     return ;
22218   }
22219   std::string arg2_str(jarg2);
22220   arg2 = &arg2_str;
22221   arg3 = (int)jarg3;
22222   arg4 = (Dali::Property::Type)jarg4;
22223   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22224   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22225   {
22226     try {
22227       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22228     } catch (std::out_of_range& e) {
22229       {
22230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22231       };
22232     } catch (std::exception& e) {
22233       {
22234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22235       };
22236     } catch (Dali::DaliException e) {
22237       {
22238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22239       };
22240     } catch (...) {
22241       {
22242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22243       };
22244     }
22245   }
22246
22247
22248   //argout typemap for const std::string&
22249
22250
22251   //argout typemap for const std::string&
22252
22253 }
22254
22255
22256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22257   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22258
22259   arg1 = (Dali::TypeRegistration *)jarg1;
22260   {
22261     try {
22262       delete arg1;
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22270       };
22271     } catch (Dali::DaliException e) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22274       };
22275     } catch (...) {
22276       {
22277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22278       };
22279     }
22280   }
22281
22282 }
22283
22284
22285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22286   void * jresult ;
22287   Dali::TypeRegistration *arg1 = 0 ;
22288   std::string *arg2 = 0 ;
22289   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22290   Dali::SignalConnectorType *result = 0 ;
22291
22292   arg1 = (Dali::TypeRegistration *)jarg1;
22293   if (!arg1) {
22294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22295     return 0;
22296   }
22297   if (!jarg2) {
22298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22299     return 0;
22300   }
22301   std::string arg2_str(jarg2);
22302   arg2 = &arg2_str;
22303   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22304   {
22305     try {
22306       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22307     } catch (std::out_of_range& e) {
22308       {
22309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22310       };
22311     } catch (std::exception& e) {
22312       {
22313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22314       };
22315     } catch (Dali::DaliException e) {
22316       {
22317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22318       };
22319     } catch (...) {
22320       {
22321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22322       };
22323     }
22324   }
22325
22326   jresult = (void *)result;
22327
22328   //argout typemap for const std::string&
22329
22330   return jresult;
22331 }
22332
22333
22334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22335   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22336
22337   arg1 = (Dali::SignalConnectorType *)jarg1;
22338   {
22339     try {
22340       delete arg1;
22341     } catch (std::out_of_range& e) {
22342       {
22343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22344       };
22345     } catch (std::exception& e) {
22346       {
22347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22348       };
22349     } catch (Dali::DaliException e) {
22350       {
22351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22352       };
22353     } catch (...) {
22354       {
22355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22356       };
22357     }
22358   }
22359
22360 }
22361
22362
22363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22364   void * jresult ;
22365   Dali::TypeRegistration *arg1 = 0 ;
22366   std::string *arg2 = 0 ;
22367   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22368   Dali::TypeAction *result = 0 ;
22369
22370   arg1 = (Dali::TypeRegistration *)jarg1;
22371   if (!arg1) {
22372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22373     return 0;
22374   }
22375   if (!jarg2) {
22376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22377     return 0;
22378   }
22379   std::string arg2_str(jarg2);
22380   arg2 = &arg2_str;
22381   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22382   {
22383     try {
22384       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22385     } catch (std::out_of_range& e) {
22386       {
22387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22388       };
22389     } catch (std::exception& e) {
22390       {
22391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22392       };
22393     } catch (Dali::DaliException e) {
22394       {
22395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22396       };
22397     } catch (...) {
22398       {
22399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22400       };
22401     }
22402   }
22403
22404   jresult = (void *)result;
22405
22406   //argout typemap for const std::string&
22407
22408   return jresult;
22409 }
22410
22411
22412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22413   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22414
22415   arg1 = (Dali::TypeAction *)jarg1;
22416   {
22417     try {
22418       delete arg1;
22419     } catch (std::out_of_range& e) {
22420       {
22421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22422       };
22423     } catch (std::exception& e) {
22424       {
22425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22426       };
22427     } catch (Dali::DaliException e) {
22428       {
22429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22430       };
22431     } catch (...) {
22432       {
22433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22434       };
22435     }
22436   }
22437
22438 }
22439
22440
22441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22442   void * jresult ;
22443   Dali::TypeRegistration *arg1 = 0 ;
22444   std::string *arg2 = 0 ;
22445   Dali::Property::Index arg3 ;
22446   Dali::Property::Type arg4 ;
22447   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22448   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22449   Dali::PropertyRegistration *result = 0 ;
22450
22451   arg1 = (Dali::TypeRegistration *)jarg1;
22452   if (!arg1) {
22453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22454     return 0;
22455   }
22456   if (!jarg2) {
22457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22458     return 0;
22459   }
22460   std::string arg2_str(jarg2);
22461   arg2 = &arg2_str;
22462   arg3 = (Dali::Property::Index)jarg3;
22463   arg4 = (Dali::Property::Type)jarg4;
22464   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22465   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22466   {
22467     try {
22468       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22469     } catch (std::out_of_range& e) {
22470       {
22471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22472       };
22473     } catch (std::exception& e) {
22474       {
22475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22476       };
22477     } catch (Dali::DaliException e) {
22478       {
22479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22480       };
22481     } catch (...) {
22482       {
22483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22484       };
22485     }
22486   }
22487
22488   jresult = (void *)result;
22489
22490   //argout typemap for const std::string&
22491
22492   return jresult;
22493 }
22494
22495
22496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22497   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22498
22499   arg1 = (Dali::PropertyRegistration *)jarg1;
22500   {
22501     try {
22502       delete arg1;
22503     } catch (std::out_of_range& e) {
22504       {
22505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22506       };
22507     } catch (std::exception& e) {
22508       {
22509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22510       };
22511     } catch (Dali::DaliException e) {
22512       {
22513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22514       };
22515     } catch (...) {
22516       {
22517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22518       };
22519     }
22520   }
22521
22522 }
22523
22524
22525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22526   void * jresult ;
22527   Dali::TypeRegistration *arg1 = 0 ;
22528   std::string *arg2 = 0 ;
22529   Dali::Property::Index arg3 ;
22530   Dali::Property::Type arg4 ;
22531   Dali::AnimatablePropertyRegistration *result = 0 ;
22532
22533   arg1 = (Dali::TypeRegistration *)jarg1;
22534   if (!arg1) {
22535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22536     return 0;
22537   }
22538   if (!jarg2) {
22539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22540     return 0;
22541   }
22542   std::string arg2_str(jarg2);
22543   arg2 = &arg2_str;
22544   arg3 = (Dali::Property::Index)jarg3;
22545   arg4 = (Dali::Property::Type)jarg4;
22546   {
22547     try {
22548       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22549     } catch (std::out_of_range& e) {
22550       {
22551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22552       };
22553     } catch (std::exception& e) {
22554       {
22555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22556       };
22557     } catch (Dali::DaliException e) {
22558       {
22559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22560       };
22561     } catch (...) {
22562       {
22563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22564       };
22565     }
22566   }
22567
22568   jresult = (void *)result;
22569
22570   //argout typemap for const std::string&
22571
22572   return jresult;
22573 }
22574
22575
22576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22577   void * jresult ;
22578   Dali::TypeRegistration *arg1 = 0 ;
22579   std::string *arg2 = 0 ;
22580   Dali::Property::Index arg3 ;
22581   Dali::Property::Value *arg4 = 0 ;
22582   Dali::AnimatablePropertyRegistration *result = 0 ;
22583
22584   arg1 = (Dali::TypeRegistration *)jarg1;
22585   if (!arg1) {
22586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22587     return 0;
22588   }
22589   if (!jarg2) {
22590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22591     return 0;
22592   }
22593   std::string arg2_str(jarg2);
22594   arg2 = &arg2_str;
22595   arg3 = (Dali::Property::Index)jarg3;
22596   arg4 = (Dali::Property::Value *)jarg4;
22597   if (!arg4) {
22598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22599     return 0;
22600   }
22601   {
22602     try {
22603       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22604     } catch (std::out_of_range& e) {
22605       {
22606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22607       };
22608     } catch (std::exception& e) {
22609       {
22610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22611       };
22612     } catch (Dali::DaliException e) {
22613       {
22614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22615       };
22616     } catch (...) {
22617       {
22618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22619       };
22620     }
22621   }
22622
22623   jresult = (void *)result;
22624
22625   //argout typemap for const std::string&
22626
22627   return jresult;
22628 }
22629
22630
22631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22632   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22633
22634   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22635   {
22636     try {
22637       delete arg1;
22638     } catch (std::out_of_range& e) {
22639       {
22640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22641       };
22642     } catch (std::exception& e) {
22643       {
22644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22645       };
22646     } catch (Dali::DaliException e) {
22647       {
22648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22649       };
22650     } catch (...) {
22651       {
22652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22653       };
22654     }
22655   }
22656
22657 }
22658
22659
22660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22661   void * jresult ;
22662   Dali::TypeRegistration *arg1 = 0 ;
22663   std::string *arg2 = 0 ;
22664   Dali::Property::Index arg3 ;
22665   Dali::Property::Index arg4 ;
22666   unsigned int arg5 ;
22667   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22668
22669   arg1 = (Dali::TypeRegistration *)jarg1;
22670   if (!arg1) {
22671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22672     return 0;
22673   }
22674   if (!jarg2) {
22675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22676     return 0;
22677   }
22678   std::string arg2_str(jarg2);
22679   arg2 = &arg2_str;
22680   arg3 = (Dali::Property::Index)jarg3;
22681   arg4 = (Dali::Property::Index)jarg4;
22682   arg5 = (unsigned int)jarg5;
22683   {
22684     try {
22685       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22686     } catch (std::out_of_range& e) {
22687       {
22688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22689       };
22690     } catch (std::exception& e) {
22691       {
22692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22693       };
22694     } catch (Dali::DaliException e) {
22695       {
22696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22697       };
22698     } catch (...) {
22699       {
22700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22701       };
22702     }
22703   }
22704
22705   jresult = (void *)result;
22706
22707   //argout typemap for const std::string&
22708
22709   return jresult;
22710 }
22711
22712
22713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22714   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22715
22716   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22717   {
22718     try {
22719       delete arg1;
22720     } catch (std::out_of_range& e) {
22721       {
22722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22723       };
22724     } catch (std::exception& e) {
22725       {
22726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22727       };
22728     } catch (Dali::DaliException e) {
22729       {
22730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22731       };
22732     } catch (...) {
22733       {
22734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22735       };
22736     }
22737   }
22738
22739 }
22740
22741
22742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22743   void * jresult ;
22744   Dali::TypeRegistration *arg1 = 0 ;
22745   std::string *arg2 = 0 ;
22746   Dali::Property::Index arg3 ;
22747   Dali::Property::Type arg4 ;
22748   Dali::ChildPropertyRegistration *result = 0 ;
22749
22750   arg1 = (Dali::TypeRegistration *)jarg1;
22751   if (!arg1) {
22752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22753     return 0;
22754   }
22755   if (!jarg2) {
22756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22757     return 0;
22758   }
22759   std::string arg2_str(jarg2);
22760   arg2 = &arg2_str;
22761   arg3 = (Dali::Property::Index)jarg3;
22762   arg4 = (Dali::Property::Type)jarg4;
22763   {
22764     try {
22765       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22766     } catch (std::out_of_range& e) {
22767       {
22768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22769       };
22770     } catch (std::exception& e) {
22771       {
22772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22773       };
22774     } catch (Dali::DaliException e) {
22775       {
22776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22777       };
22778     } catch (...) {
22779       {
22780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22781       };
22782     }
22783   }
22784
22785   jresult = (void *)result;
22786
22787   //argout typemap for const std::string&
22788
22789   return jresult;
22790 }
22791
22792
22793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22794   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22795
22796   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22797   {
22798     try {
22799       delete arg1;
22800     } catch (std::out_of_range& e) {
22801       {
22802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22803       };
22804     } catch (std::exception& e) {
22805       {
22806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22807       };
22808     } catch (Dali::DaliException e) {
22809       {
22810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22811       };
22812     } catch (...) {
22813       {
22814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22815       };
22816     }
22817   }
22818
22819 }
22820
22821
22822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22823   unsigned int jresult ;
22824   std::string *arg1 = 0 ;
22825   std::type_info *arg2 = 0 ;
22826   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22827   bool result;
22828
22829   if (!jarg1) {
22830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22831     return 0;
22832   }
22833   std::string arg1_str(jarg1);
22834   arg1 = &arg1_str;
22835   arg2 = (std::type_info *)jarg2;
22836   if (!arg2) {
22837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22838     return 0;
22839   }
22840   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22841   {
22842     try {
22843       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22844     } catch (std::out_of_range& e) {
22845       {
22846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22847       };
22848     } catch (std::exception& e) {
22849       {
22850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22851       };
22852     } catch (Dali::DaliException e) {
22853       {
22854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22855       };
22856     } catch (...) {
22857       {
22858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22859       };
22860     }
22861   }
22862
22863   jresult = result;
22864
22865   //argout typemap for const std::string&
22866
22867   return jresult;
22868 }
22869
22870
22871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22872   unsigned int jresult ;
22873   std::string *arg1 = 0 ;
22874   std::string *arg2 = 0 ;
22875   Dali::Property::Index arg3 ;
22876   Dali::Property::Type arg4 ;
22877   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22878   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22879   bool result;
22880
22881   if (!jarg1) {
22882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22883     return 0;
22884   }
22885   std::string arg1_str(jarg1);
22886   arg1 = &arg1_str;
22887   if (!jarg2) {
22888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22889     return 0;
22890   }
22891   std::string arg2_str(jarg2);
22892   arg2 = &arg2_str;
22893   arg3 = (Dali::Property::Index)jarg3;
22894   arg4 = (Dali::Property::Type)jarg4;
22895   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22896   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22897   {
22898     try {
22899       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22900     } catch (std::out_of_range& e) {
22901       {
22902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22903       };
22904     } catch (std::exception& e) {
22905       {
22906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22907       };
22908     } catch (Dali::DaliException e) {
22909       {
22910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22911       };
22912     } catch (...) {
22913       {
22914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22915       };
22916     }
22917   }
22918
22919   jresult = result;
22920
22921   //argout typemap for const std::string&
22922
22923
22924   //argout typemap for const std::string&
22925
22926   return jresult;
22927 }
22928
22929
22930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22931   float jresult ;
22932   float result;
22933
22934   result = (float)(float)Dali::ParentOrigin::TOP;
22935   jresult = result;
22936   return jresult;
22937 }
22938
22939
22940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22941   float jresult ;
22942   float result;
22943
22944   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22945   jresult = result;
22946   return jresult;
22947 }
22948
22949
22950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22951   float jresult ;
22952   float result;
22953
22954   result = (float)(float)Dali::ParentOrigin::LEFT;
22955   jresult = result;
22956   return jresult;
22957 }
22958
22959
22960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22961   float jresult ;
22962   float result;
22963
22964   result = (float)(float)Dali::ParentOrigin::RIGHT;
22965   jresult = result;
22966   return jresult;
22967 }
22968
22969
22970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22971   float jresult ;
22972   float result;
22973
22974   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22975   jresult = result;
22976   return jresult;
22977 }
22978
22979
22980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22981   void * jresult ;
22982   Dali::Vector3 *result = 0 ;
22983
22984   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22985   jresult = (void *)result;
22986   return jresult;
22987 }
22988
22989
22990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22991   void * jresult ;
22992   Dali::Vector3 *result = 0 ;
22993
22994   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22995   jresult = (void *)result;
22996   return jresult;
22997 }
22998
22999
23000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23001   void * jresult ;
23002   Dali::Vector3 *result = 0 ;
23003
23004   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23005   jresult = (void *)result;
23006   return jresult;
23007 }
23008
23009
23010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23011   void * jresult ;
23012   Dali::Vector3 *result = 0 ;
23013
23014   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23015   jresult = (void *)result;
23016   return jresult;
23017 }
23018
23019
23020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23021   void * jresult ;
23022   Dali::Vector3 *result = 0 ;
23023
23024   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23025   jresult = (void *)result;
23026   return jresult;
23027 }
23028
23029
23030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23031   void * jresult ;
23032   Dali::Vector3 *result = 0 ;
23033
23034   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23035   jresult = (void *)result;
23036   return jresult;
23037 }
23038
23039
23040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23041   void * jresult ;
23042   Dali::Vector3 *result = 0 ;
23043
23044   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23045   jresult = (void *)result;
23046   return jresult;
23047 }
23048
23049
23050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23051   void * jresult ;
23052   Dali::Vector3 *result = 0 ;
23053
23054   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23055   jresult = (void *)result;
23056   return jresult;
23057 }
23058
23059
23060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23061   void * jresult ;
23062   Dali::Vector3 *result = 0 ;
23063
23064   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23065   jresult = (void *)result;
23066   return jresult;
23067 }
23068
23069
23070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23071   float jresult ;
23072   float result;
23073
23074   result = (float)(float)Dali::AnchorPoint::TOP;
23075   jresult = result;
23076   return jresult;
23077 }
23078
23079
23080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23081   float jresult ;
23082   float result;
23083
23084   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23085   jresult = result;
23086   return jresult;
23087 }
23088
23089
23090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23091   float jresult ;
23092   float result;
23093
23094   result = (float)(float)Dali::AnchorPoint::LEFT;
23095   jresult = result;
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23101   float jresult ;
23102   float result;
23103
23104   result = (float)(float)Dali::AnchorPoint::RIGHT;
23105   jresult = result;
23106   return jresult;
23107 }
23108
23109
23110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23111   float jresult ;
23112   float result;
23113
23114   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23115   jresult = result;
23116   return jresult;
23117 }
23118
23119
23120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23121   void * jresult ;
23122   Dali::Vector3 *result = 0 ;
23123
23124   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23125   jresult = (void *)result;
23126   return jresult;
23127 }
23128
23129
23130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23131   void * jresult ;
23132   Dali::Vector3 *result = 0 ;
23133
23134   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23135   jresult = (void *)result;
23136   return jresult;
23137 }
23138
23139
23140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23141   void * jresult ;
23142   Dali::Vector3 *result = 0 ;
23143
23144   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23145   jresult = (void *)result;
23146   return jresult;
23147 }
23148
23149
23150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23151   void * jresult ;
23152   Dali::Vector3 *result = 0 ;
23153
23154   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23155   jresult = (void *)result;
23156   return jresult;
23157 }
23158
23159
23160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23161   void * jresult ;
23162   Dali::Vector3 *result = 0 ;
23163
23164   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23165   jresult = (void *)result;
23166   return jresult;
23167 }
23168
23169
23170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23171   void * jresult ;
23172   Dali::Vector3 *result = 0 ;
23173
23174   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23175   jresult = (void *)result;
23176   return jresult;
23177 }
23178
23179
23180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23181   void * jresult ;
23182   Dali::Vector3 *result = 0 ;
23183
23184   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23185   jresult = (void *)result;
23186   return jresult;
23187 }
23188
23189
23190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23191   void * jresult ;
23192   Dali::Vector3 *result = 0 ;
23193
23194   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23195   jresult = (void *)result;
23196   return jresult;
23197 }
23198
23199
23200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23201   void * jresult ;
23202   Dali::Vector3 *result = 0 ;
23203
23204   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23205   jresult = (void *)result;
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23211   void * jresult ;
23212   Dali::Vector4 *result = 0 ;
23213
23214   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23215   jresult = (void *)result;
23216   return jresult;
23217 }
23218
23219
23220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23221   void * jresult ;
23222   Dali::Vector4 *result = 0 ;
23223
23224   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23225   jresult = (void *)result;
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23231   void * jresult ;
23232   Dali::Vector4 *result = 0 ;
23233
23234   result = (Dali::Vector4 *)&Dali::Color::RED;
23235   jresult = (void *)result;
23236   return jresult;
23237 }
23238
23239
23240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23241   void * jresult ;
23242   Dali::Vector4 *result = 0 ;
23243
23244   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23245   jresult = (void *)result;
23246   return jresult;
23247 }
23248
23249
23250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23251   void * jresult ;
23252   Dali::Vector4 *result = 0 ;
23253
23254   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23255   jresult = (void *)result;
23256   return jresult;
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23261   void * jresult ;
23262   Dali::Vector4 *result = 0 ;
23263
23264   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23265   jresult = (void *)result;
23266   return jresult;
23267 }
23268
23269
23270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23271   void * jresult ;
23272   Dali::Vector4 *result = 0 ;
23273
23274   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23275   jresult = (void *)result;
23276   return jresult;
23277 }
23278
23279
23280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23281   void * jresult ;
23282   Dali::Vector4 *result = 0 ;
23283
23284   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23285   jresult = (void *)result;
23286   return jresult;
23287 }
23288
23289
23290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23291   void * jresult ;
23292   Dali::Vector4 *result = 0 ;
23293
23294   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23295   jresult = (void *)result;
23296   return jresult;
23297 }
23298
23299
23300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23301   float jresult ;
23302   float result;
23303
23304   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23305   jresult = result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23311   float jresult ;
23312   float result;
23313
23314   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23315   jresult = result;
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23321   float jresult ;
23322   float result;
23323
23324   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23325   jresult = result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23331   float jresult ;
23332   float result;
23333
23334   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23335   jresult = result;
23336   return jresult;
23337 }
23338
23339
23340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23341   float jresult ;
23342   float result;
23343
23344   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23345   jresult = result;
23346   return jresult;
23347 }
23348
23349
23350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23351   float jresult ;
23352   float result;
23353
23354   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23355   jresult = result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23361   float jresult ;
23362   float result;
23363
23364   result = (float)(float)Dali::Math::PI;
23365   jresult = result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23371   float jresult ;
23372   float result;
23373
23374   result = (float)(float)Dali::Math::PI_2;
23375   jresult = result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23381   float jresult ;
23382   float result;
23383
23384   result = (float)(float)Dali::Math::PI_4;
23385   jresult = result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23391   float jresult ;
23392   float result;
23393
23394   result = (float)(float)Dali::Math::PI_OVER_180;
23395   jresult = result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23401   float jresult ;
23402   float result;
23403
23404   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23405   jresult = result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23411   int jresult ;
23412   Dali::ResizePolicy::Type result;
23413
23414   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23421   unsigned long jresult ;
23422   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23423   Dali::VectorBase::SizeType result;
23424
23425   arg1 = (Dali::VectorBase *)jarg1;
23426   {
23427     try {
23428       result = ((Dali::VectorBase const *)arg1)->Count();
23429     } catch (std::out_of_range& e) {
23430       {
23431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23432       };
23433     } catch (std::exception& e) {
23434       {
23435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23436       };
23437     } catch (Dali::DaliException e) {
23438       {
23439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23440       };
23441     } catch (...) {
23442       {
23443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23444       };
23445     }
23446   }
23447
23448   jresult = (unsigned long)result;
23449   return jresult;
23450 }
23451
23452
23453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23454   unsigned long jresult ;
23455   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23456   Dali::VectorBase::SizeType result;
23457
23458   arg1 = (Dali::VectorBase *)jarg1;
23459   {
23460     try {
23461       result = ((Dali::VectorBase const *)arg1)->Size();
23462     } catch (std::out_of_range& e) {
23463       {
23464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23465       };
23466     } catch (std::exception& e) {
23467       {
23468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23469       };
23470     } catch (Dali::DaliException e) {
23471       {
23472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23473       };
23474     } catch (...) {
23475       {
23476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23477       };
23478     }
23479   }
23480
23481   jresult = (unsigned long)result;
23482   return jresult;
23483 }
23484
23485
23486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23487   unsigned int jresult ;
23488   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23489   bool result;
23490
23491   arg1 = (Dali::VectorBase *)jarg1;
23492   {
23493     try {
23494       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23495     } catch (std::out_of_range& e) {
23496       {
23497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23498       };
23499     } catch (std::exception& e) {
23500       {
23501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23502       };
23503     } catch (Dali::DaliException e) {
23504       {
23505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23506       };
23507     } catch (...) {
23508       {
23509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23510       };
23511     }
23512   }
23513
23514   jresult = result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23520   unsigned long jresult ;
23521   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23522   Dali::VectorBase::SizeType result;
23523
23524   arg1 = (Dali::VectorBase *)jarg1;
23525   {
23526     try {
23527       result = ((Dali::VectorBase const *)arg1)->Capacity();
23528     } catch (std::out_of_range& e) {
23529       {
23530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23531       };
23532     } catch (std::exception& e) {
23533       {
23534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23535       };
23536     } catch (Dali::DaliException e) {
23537       {
23538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23539       };
23540     } catch (...) {
23541       {
23542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23543       };
23544     }
23545   }
23546
23547   jresult = (unsigned long)result;
23548   return jresult;
23549 }
23550
23551
23552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23553   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23554
23555   arg1 = (Dali::VectorBase *)jarg1;
23556   {
23557     try {
23558       (arg1)->Release();
23559     } catch (std::out_of_range& e) {
23560       {
23561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23562       };
23563     } catch (std::exception& e) {
23564       {
23565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23566       };
23567     } catch (Dali::DaliException e) {
23568       {
23569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23570       };
23571     } catch (...) {
23572       {
23573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23574       };
23575     }
23576   }
23577
23578 }
23579
23580
23581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23582   int jresult ;
23583   Dali::Pixel::Format result;
23584
23585   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23586   jresult = (int)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23592   int jresult ;
23593   Dali::Pixel::Format result;
23594
23595   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23596   jresult = (int)result;
23597   return jresult;
23598 }
23599
23600
23601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23602   unsigned int jresult ;
23603   Dali::Pixel::Format arg1 ;
23604   bool result;
23605
23606   arg1 = (Dali::Pixel::Format)jarg1;
23607   {
23608     try {
23609       result = (bool)Dali::Pixel::HasAlpha(arg1);
23610     } catch (std::out_of_range& e) {
23611       {
23612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23613       };
23614     } catch (std::exception& e) {
23615       {
23616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23617       };
23618     } catch (Dali::DaliException e) {
23619       {
23620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23621       };
23622     } catch (...) {
23623       {
23624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23625       };
23626     }
23627   }
23628
23629   jresult = result;
23630   return jresult;
23631 }
23632
23633
23634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23635   unsigned int jresult ;
23636   Dali::Pixel::Format arg1 ;
23637   unsigned int result;
23638
23639   arg1 = (Dali::Pixel::Format)jarg1;
23640   {
23641     try {
23642       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23643     } catch (std::out_of_range& e) {
23644       {
23645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23646       };
23647     } catch (std::exception& e) {
23648       {
23649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23650       };
23651     } catch (Dali::DaliException e) {
23652       {
23653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23654       };
23655     } catch (...) {
23656       {
23657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23658       };
23659     }
23660   }
23661
23662   jresult = result;
23663   return jresult;
23664 }
23665
23666
23667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23668   Dali::Pixel::Format arg1 ;
23669   int *arg2 = 0 ;
23670   int *arg3 = 0 ;
23671
23672   arg1 = (Dali::Pixel::Format)jarg1;
23673   arg2 = (int *)jarg2;
23674   if (!arg2) {
23675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23676     return ;
23677   }
23678   arg3 = (int *)jarg3;
23679   if (!arg3) {
23680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23681     return ;
23682   }
23683   {
23684     try {
23685       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23686     } catch (std::out_of_range& e) {
23687       {
23688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23689       };
23690     } catch (std::exception& e) {
23691       {
23692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23693       };
23694     } catch (Dali::DaliException e) {
23695       {
23696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23697       };
23698     } catch (...) {
23699       {
23700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23701       };
23702     }
23703   }
23704
23705 }
23706
23707
23708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23709   void * jresult ;
23710   unsigned char *arg1 = (unsigned char *) 0 ;
23711   unsigned int arg2 ;
23712   unsigned int arg3 ;
23713   unsigned int arg4 ;
23714   Dali::Pixel::Format arg5 ;
23715   Dali::PixelData::ReleaseFunction arg6 ;
23716   Dali::PixelData result;
23717
23718   arg1 = jarg1;
23719   arg2 = (unsigned int)jarg2;
23720   arg3 = (unsigned int)jarg3;
23721   arg4 = (unsigned int)jarg4;
23722   arg5 = (Dali::Pixel::Format)jarg5;
23723   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23724   {
23725     try {
23726       auto pixelBuffer = new unsigned char[jarg2];
23727       memcpy( pixelBuffer, arg1, arg2);
23728       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23729     } catch (std::out_of_range& e) {
23730       {
23731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23732       };
23733     } catch (std::exception& e) {
23734       {
23735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23736       };
23737     } catch (Dali::DaliException e) {
23738       {
23739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23740       };
23741     } catch (...) {
23742       {
23743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23744       };
23745     }
23746   }
23747
23748   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23749
23750
23751   return jresult;
23752 }
23753
23754
23755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23756   void * jresult ;
23757   Dali::PixelData *result = 0 ;
23758
23759   {
23760     try {
23761       result = (Dali::PixelData *)new Dali::PixelData();
23762     } catch (std::out_of_range& e) {
23763       {
23764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23765       };
23766     } catch (std::exception& e) {
23767       {
23768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23769       };
23770     } catch (Dali::DaliException e) {
23771       {
23772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23773       };
23774     } catch (...) {
23775       {
23776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23777       };
23778     }
23779   }
23780
23781   jresult = (void *)result;
23782   return jresult;
23783 }
23784
23785
23786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23787   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23788
23789   arg1 = (Dali::PixelData *)jarg1;
23790   {
23791     try {
23792       delete arg1;
23793     } catch (std::out_of_range& e) {
23794       {
23795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23796       };
23797     } catch (std::exception& e) {
23798       {
23799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23800       };
23801     } catch (Dali::DaliException e) {
23802       {
23803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23804       };
23805     } catch (...) {
23806       {
23807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23808       };
23809     }
23810   }
23811
23812 }
23813
23814
23815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23816   void * jresult ;
23817   Dali::PixelData *arg1 = 0 ;
23818   Dali::PixelData *result = 0 ;
23819
23820   arg1 = (Dali::PixelData *)jarg1;
23821   if (!arg1) {
23822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23823     return 0;
23824   }
23825   {
23826     try {
23827       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23828     } catch (std::out_of_range& e) {
23829       {
23830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23831       };
23832     } catch (std::exception& e) {
23833       {
23834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23835       };
23836     } catch (Dali::DaliException e) {
23837       {
23838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23839       };
23840     } catch (...) {
23841       {
23842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23843       };
23844     }
23845   }
23846
23847   jresult = (void *)result;
23848   return jresult;
23849 }
23850
23851
23852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23853   void * jresult ;
23854   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23855   Dali::PixelData *arg2 = 0 ;
23856   Dali::PixelData *result = 0 ;
23857
23858   arg1 = (Dali::PixelData *)jarg1;
23859   arg2 = (Dali::PixelData *)jarg2;
23860   if (!arg2) {
23861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23862     return 0;
23863   }
23864   {
23865     try {
23866       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23867     } catch (std::out_of_range& e) {
23868       {
23869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (std::exception& e) {
23872       {
23873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23874       };
23875     } catch (Dali::DaliException e) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23878       };
23879     } catch (...) {
23880       {
23881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23882       };
23883     }
23884   }
23885
23886   jresult = (void *)result;
23887   return jresult;
23888 }
23889
23890
23891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23892   unsigned int jresult ;
23893   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23894   unsigned int result;
23895
23896   arg1 = (Dali::PixelData *)jarg1;
23897   {
23898     try {
23899       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23900     } catch (std::out_of_range& e) {
23901       {
23902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (std::exception& e) {
23905       {
23906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23907       };
23908     } catch (Dali::DaliException e) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23911       };
23912     } catch (...) {
23913       {
23914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23915       };
23916     }
23917   }
23918
23919   jresult = result;
23920   return jresult;
23921 }
23922
23923
23924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23925   unsigned int jresult ;
23926   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23927   unsigned int result;
23928
23929   arg1 = (Dali::PixelData *)jarg1;
23930   {
23931     try {
23932       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23933     } catch (std::out_of_range& e) {
23934       {
23935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23936       };
23937     } catch (std::exception& e) {
23938       {
23939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23940       };
23941     } catch (Dali::DaliException e) {
23942       {
23943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23944       };
23945     } catch (...) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23948       };
23949     }
23950   }
23951
23952   jresult = result;
23953   return jresult;
23954 }
23955
23956
23957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23958   int jresult ;
23959   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23960   Dali::Pixel::Format result;
23961
23962   arg1 = (Dali::PixelData *)jarg1;
23963   {
23964     try {
23965       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23973       };
23974     } catch (Dali::DaliException e) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23977       };
23978     } catch (...) {
23979       {
23980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23981       };
23982     }
23983   }
23984
23985   jresult = (int)result;
23986   return jresult;
23987 }
23988
23989
23990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23991   unsigned int jresult ;
23992   unsigned int result;
23993
23994   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23995   jresult = result;
23996   return jresult;
23997 }
23998
23999
24000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24001   unsigned int jresult ;
24002   unsigned int result;
24003
24004   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24005   jresult = result;
24006   return jresult;
24007 }
24008
24009
24010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24011   unsigned int jresult ;
24012   unsigned int result;
24013
24014   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24015   jresult = result;
24016   return jresult;
24017 }
24018
24019
24020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24021   unsigned int jresult ;
24022   unsigned int result;
24023
24024   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24025   jresult = result;
24026   return jresult;
24027 }
24028
24029
24030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24031   unsigned int jresult ;
24032   unsigned int result;
24033
24034   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24035   jresult = result;
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24041   unsigned int jresult ;
24042   unsigned int result;
24043
24044   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24045   jresult = result;
24046   return jresult;
24047 }
24048
24049
24050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24051   void * jresult ;
24052   Dali::TextureType::Type arg1 ;
24053   Dali::Pixel::Format arg2 ;
24054   unsigned int arg3 ;
24055   unsigned int arg4 ;
24056   Dali::Texture result;
24057
24058   arg1 = (Dali::TextureType::Type)jarg1;
24059   arg2 = (Dali::Pixel::Format)jarg2;
24060   arg3 = (unsigned int)jarg3;
24061   arg4 = (unsigned int)jarg4;
24062   {
24063     try {
24064       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24065     } catch (std::out_of_range& e) {
24066       {
24067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24068       };
24069     } catch (std::exception& e) {
24070       {
24071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24072       };
24073     } catch (Dali::DaliException e) {
24074       {
24075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24076       };
24077     } catch (...) {
24078       {
24079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24080       };
24081     }
24082   }
24083
24084   jresult = new Dali::Texture((const Dali::Texture &)result);
24085   return jresult;
24086 }
24087
24088
24089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24090   void * jresult ;
24091   NativeImageInterface *arg1 = 0 ;
24092   Dali::Texture result;
24093
24094   arg1 = (NativeImageInterface *)jarg1;
24095   if (!arg1) {
24096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24097     return 0;
24098   }
24099   {
24100     try {
24101       result = Dali::Texture::New(*arg1);
24102     } catch (std::out_of_range& e) {
24103       {
24104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24105       };
24106     } catch (std::exception& e) {
24107       {
24108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24109       };
24110     } catch (Dali::DaliException e) {
24111       {
24112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24113       };
24114     } catch (...) {
24115       {
24116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24117       };
24118     }
24119   }
24120
24121   jresult = new Dali::Texture((const Dali::Texture &)result);
24122   return jresult;
24123 }
24124
24125
24126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24127   void * jresult ;
24128   Dali::Texture *result = 0 ;
24129
24130   {
24131     try {
24132       result = (Dali::Texture *)new Dali::Texture();
24133     } catch (std::out_of_range& e) {
24134       {
24135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24136       };
24137     } catch (std::exception& e) {
24138       {
24139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24140       };
24141     } catch (Dali::DaliException e) {
24142       {
24143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24144       };
24145     } catch (...) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24148       };
24149     }
24150   }
24151
24152   jresult = (void *)result;
24153   return jresult;
24154 }
24155
24156
24157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24158   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24159
24160   arg1 = (Dali::Texture *)jarg1;
24161   {
24162     try {
24163       delete arg1;
24164     } catch (std::out_of_range& e) {
24165       {
24166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24167       };
24168     } catch (std::exception& e) {
24169       {
24170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24171       };
24172     } catch (Dali::DaliException e) {
24173       {
24174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24175       };
24176     } catch (...) {
24177       {
24178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24179       };
24180     }
24181   }
24182
24183 }
24184
24185
24186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24187   void * jresult ;
24188   Dali::Texture *arg1 = 0 ;
24189   Dali::Texture *result = 0 ;
24190
24191   arg1 = (Dali::Texture *)jarg1;
24192   if (!arg1) {
24193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24194     return 0;
24195   }
24196   {
24197     try {
24198       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24199     } catch (std::out_of_range& e) {
24200       {
24201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24202       };
24203     } catch (std::exception& e) {
24204       {
24205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24206       };
24207     } catch (Dali::DaliException e) {
24208       {
24209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24210       };
24211     } catch (...) {
24212       {
24213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24214       };
24215     }
24216   }
24217
24218   jresult = (void *)result;
24219   return jresult;
24220 }
24221
24222
24223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24224   void * jresult ;
24225   Dali::BaseHandle arg1 ;
24226   Dali::BaseHandle *argp1 ;
24227   Dali::Texture result;
24228
24229   argp1 = (Dali::BaseHandle *)jarg1;
24230   if (!argp1) {
24231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24232     return 0;
24233   }
24234   arg1 = *argp1;
24235   {
24236     try {
24237       result = Dali::Texture::DownCast(arg1);
24238     } catch (std::out_of_range& e) {
24239       {
24240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24241       };
24242     } catch (std::exception& e) {
24243       {
24244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24245       };
24246     } catch (Dali::DaliException e) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24249       };
24250     } catch (...) {
24251       {
24252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24253       };
24254     }
24255   }
24256
24257   jresult = new Dali::Texture((const Dali::Texture &)result);
24258   return jresult;
24259 }
24260
24261
24262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24263   void * jresult ;
24264   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24265   Dali::Texture *arg2 = 0 ;
24266   Dali::Texture *result = 0 ;
24267
24268   arg1 = (Dali::Texture *)jarg1;
24269   arg2 = (Dali::Texture *)jarg2;
24270   if (!arg2) {
24271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24272     return 0;
24273   }
24274   {
24275     try {
24276       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24277     } catch (std::out_of_range& e) {
24278       {
24279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (std::exception& e) {
24282       {
24283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24284       };
24285     } catch (Dali::DaliException e) {
24286       {
24287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24288       };
24289     } catch (...) {
24290       {
24291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24292       };
24293     }
24294   }
24295
24296   jresult = (void *)result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24302   unsigned int jresult ;
24303   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24304   Dali::PixelData arg2 ;
24305   Dali::PixelData *argp2 ;
24306   bool result;
24307
24308   arg1 = (Dali::Texture *)jarg1;
24309   argp2 = (Dali::PixelData *)jarg2;
24310   if (!argp2) {
24311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24312     return 0;
24313   }
24314   arg2 = *argp2;
24315   {
24316     try {
24317       result = (bool)(arg1)->Upload(arg2);
24318     } catch (std::out_of_range& e) {
24319       {
24320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24321       };
24322     } catch (std::exception& e) {
24323       {
24324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24325       };
24326     } catch (Dali::DaliException e) {
24327       {
24328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24329       };
24330     } catch (...) {
24331       {
24332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24333       };
24334     }
24335   }
24336
24337   jresult = result;
24338   return jresult;
24339 }
24340
24341
24342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24343   unsigned int jresult ;
24344   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24345   Dali::PixelData arg2 ;
24346   unsigned int arg3 ;
24347   unsigned int arg4 ;
24348   unsigned int arg5 ;
24349   unsigned int arg6 ;
24350   unsigned int arg7 ;
24351   unsigned int arg8 ;
24352   Dali::PixelData *argp2 ;
24353   bool result;
24354
24355   arg1 = (Dali::Texture *)jarg1;
24356   argp2 = (Dali::PixelData *)jarg2;
24357   if (!argp2) {
24358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24359     return 0;
24360   }
24361   arg2 = *argp2;
24362   arg3 = (unsigned int)jarg3;
24363   arg4 = (unsigned int)jarg4;
24364   arg5 = (unsigned int)jarg5;
24365   arg6 = (unsigned int)jarg6;
24366   arg7 = (unsigned int)jarg7;
24367   arg8 = (unsigned int)jarg8;
24368   {
24369     try {
24370       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24371     } catch (std::out_of_range& e) {
24372       {
24373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24374       };
24375     } catch (std::exception& e) {
24376       {
24377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24378       };
24379     } catch (Dali::DaliException e) {
24380       {
24381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24382       };
24383     } catch (...) {
24384       {
24385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24386       };
24387     }
24388   }
24389
24390   jresult = result;
24391   return jresult;
24392 }
24393
24394
24395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24396   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24397
24398   arg1 = (Dali::Texture *)jarg1;
24399   {
24400     try {
24401       (arg1)->GenerateMipmaps();
24402     } catch (std::out_of_range& e) {
24403       {
24404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24405       };
24406     } catch (std::exception& e) {
24407       {
24408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24409       };
24410     } catch (Dali::DaliException e) {
24411       {
24412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24413       };
24414     } catch (...) {
24415       {
24416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24417       };
24418     }
24419   }
24420
24421 }
24422
24423
24424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24425   unsigned int jresult ;
24426   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24427   unsigned int result;
24428
24429   arg1 = (Dali::Texture *)jarg1;
24430   {
24431     try {
24432       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24433     } catch (std::out_of_range& e) {
24434       {
24435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24436       };
24437     } catch (std::exception& e) {
24438       {
24439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24440       };
24441     } catch (Dali::DaliException e) {
24442       {
24443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24444       };
24445     } catch (...) {
24446       {
24447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24448       };
24449     }
24450   }
24451
24452   jresult = result;
24453   return jresult;
24454 }
24455
24456
24457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24458   unsigned int jresult ;
24459   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24460   unsigned int result;
24461
24462   arg1 = (Dali::Texture *)jarg1;
24463   {
24464     try {
24465       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24466     } catch (std::out_of_range& e) {
24467       {
24468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24469       };
24470     } catch (std::exception& e) {
24471       {
24472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24473       };
24474     } catch (Dali::DaliException e) {
24475       {
24476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24477       };
24478     } catch (...) {
24479       {
24480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24481       };
24482     }
24483   }
24484
24485   jresult = result;
24486   return jresult;
24487 }
24488
24489
24490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24491   void * jresult ;
24492   Dali::Sampler result;
24493
24494   {
24495     try {
24496       result = Dali::Sampler::New();
24497     } catch (std::out_of_range& e) {
24498       {
24499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24500       };
24501     } catch (std::exception& e) {
24502       {
24503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24504       };
24505     } catch (Dali::DaliException e) {
24506       {
24507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24508       };
24509     } catch (...) {
24510       {
24511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24512       };
24513     }
24514   }
24515
24516   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24517   return jresult;
24518 }
24519
24520
24521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24522   void * jresult ;
24523   Dali::Sampler *result = 0 ;
24524
24525   {
24526     try {
24527       result = (Dali::Sampler *)new Dali::Sampler();
24528     } catch (std::out_of_range& e) {
24529       {
24530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (std::exception& e) {
24533       {
24534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (Dali::DaliException e) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546
24547   jresult = (void *)result;
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24553   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24554
24555   arg1 = (Dali::Sampler *)jarg1;
24556   {
24557     try {
24558       delete arg1;
24559     } catch (std::out_of_range& e) {
24560       {
24561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24562       };
24563     } catch (std::exception& e) {
24564       {
24565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24566       };
24567     } catch (Dali::DaliException e) {
24568       {
24569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24570       };
24571     } catch (...) {
24572       {
24573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24574       };
24575     }
24576   }
24577
24578 }
24579
24580
24581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24582   void * jresult ;
24583   Dali::Sampler *arg1 = 0 ;
24584   Dali::Sampler *result = 0 ;
24585
24586   arg1 = (Dali::Sampler *)jarg1;
24587   if (!arg1) {
24588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24589     return 0;
24590   }
24591   {
24592     try {
24593       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24594     } catch (std::out_of_range& e) {
24595       {
24596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24597       };
24598     } catch (std::exception& e) {
24599       {
24600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24601       };
24602     } catch (Dali::DaliException e) {
24603       {
24604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24605       };
24606     } catch (...) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24609       };
24610     }
24611   }
24612
24613   jresult = (void *)result;
24614   return jresult;
24615 }
24616
24617
24618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24619   void * jresult ;
24620   Dali::BaseHandle arg1 ;
24621   Dali::BaseHandle *argp1 ;
24622   Dali::Sampler result;
24623
24624   argp1 = (Dali::BaseHandle *)jarg1;
24625   if (!argp1) {
24626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24627     return 0;
24628   }
24629   arg1 = *argp1;
24630   {
24631     try {
24632       result = Dali::Sampler::DownCast(arg1);
24633     } catch (std::out_of_range& e) {
24634       {
24635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (std::exception& e) {
24638       {
24639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24640       };
24641     } catch (Dali::DaliException e) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24644       };
24645     } catch (...) {
24646       {
24647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24648       };
24649     }
24650   }
24651
24652   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24653   return jresult;
24654 }
24655
24656
24657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24658   void * jresult ;
24659   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24660   Dali::Sampler *arg2 = 0 ;
24661   Dali::Sampler *result = 0 ;
24662
24663   arg1 = (Dali::Sampler *)jarg1;
24664   arg2 = (Dali::Sampler *)jarg2;
24665   if (!arg2) {
24666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24667     return 0;
24668   }
24669   {
24670     try {
24671       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24672     } catch (std::out_of_range& e) {
24673       {
24674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24675       };
24676     } catch (std::exception& e) {
24677       {
24678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24679       };
24680     } catch (Dali::DaliException e) {
24681       {
24682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24683       };
24684     } catch (...) {
24685       {
24686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24687       };
24688     }
24689   }
24690
24691   jresult = (void *)result;
24692   return jresult;
24693 }
24694
24695
24696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24697   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24698   Dali::FilterMode::Type arg2 ;
24699   Dali::FilterMode::Type arg3 ;
24700
24701   arg1 = (Dali::Sampler *)jarg1;
24702   arg2 = (Dali::FilterMode::Type)jarg2;
24703   arg3 = (Dali::FilterMode::Type)jarg3;
24704   {
24705     try {
24706       (arg1)->SetFilterMode(arg2,arg3);
24707     } catch (std::out_of_range& e) {
24708       {
24709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24710       };
24711     } catch (std::exception& e) {
24712       {
24713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24714       };
24715     } catch (Dali::DaliException e) {
24716       {
24717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24718       };
24719     } catch (...) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24722       };
24723     }
24724   }
24725
24726 }
24727
24728
24729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24730   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24731   Dali::WrapMode::Type arg2 ;
24732   Dali::WrapMode::Type arg3 ;
24733
24734   arg1 = (Dali::Sampler *)jarg1;
24735   arg2 = (Dali::WrapMode::Type)jarg2;
24736   arg3 = (Dali::WrapMode::Type)jarg3;
24737   {
24738     try {
24739       (arg1)->SetWrapMode(arg2,arg3);
24740     } catch (std::out_of_range& e) {
24741       {
24742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24743       };
24744     } catch (std::exception& e) {
24745       {
24746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24747       };
24748     } catch (Dali::DaliException e) {
24749       {
24750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24751       };
24752     } catch (...) {
24753       {
24754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24755       };
24756     }
24757   }
24758
24759 }
24760
24761
24762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24763   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24764   Dali::WrapMode::Type arg2 ;
24765   Dali::WrapMode::Type arg3 ;
24766   Dali::WrapMode::Type arg4 ;
24767
24768   arg1 = (Dali::Sampler *)jarg1;
24769   arg2 = (Dali::WrapMode::Type)jarg2;
24770   arg3 = (Dali::WrapMode::Type)jarg3;
24771   arg4 = (Dali::WrapMode::Type)jarg4;
24772   {
24773     try {
24774       (arg1)->SetWrapMode(arg2,arg3,arg4);
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 (Dali::DaliException e) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24786       };
24787     } catch (...) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24790       };
24791     }
24792   }
24793
24794 }
24795
24796
24797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24798   void * jresult ;
24799   Dali::TextureSet result;
24800
24801   {
24802     try {
24803       result = Dali::TextureSet::New();
24804     } catch (std::out_of_range& e) {
24805       {
24806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24807       };
24808     } catch (std::exception& e) {
24809       {
24810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24811       };
24812     } catch (Dali::DaliException e) {
24813       {
24814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24815       };
24816     } catch (...) {
24817       {
24818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24819       };
24820     }
24821   }
24822
24823   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24824   return jresult;
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24829   void * jresult ;
24830   Dali::TextureSet *result = 0 ;
24831
24832   {
24833     try {
24834       result = (Dali::TextureSet *)new Dali::TextureSet();
24835     } catch (std::out_of_range& e) {
24836       {
24837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24838       };
24839     } catch (std::exception& e) {
24840       {
24841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (Dali::DaliException e) {
24844       {
24845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24846       };
24847     } catch (...) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24850       };
24851     }
24852   }
24853
24854   jresult = (void *)result;
24855   return jresult;
24856 }
24857
24858
24859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24860   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24861
24862   arg1 = (Dali::TextureSet *)jarg1;
24863   {
24864     try {
24865       delete arg1;
24866     } catch (std::out_of_range& e) {
24867       {
24868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24869       };
24870     } catch (std::exception& e) {
24871       {
24872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24873       };
24874     } catch (Dali::DaliException e) {
24875       {
24876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24877       };
24878     } catch (...) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24881       };
24882     }
24883   }
24884
24885 }
24886
24887
24888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24889   void * jresult ;
24890   Dali::TextureSet *arg1 = 0 ;
24891   Dali::TextureSet *result = 0 ;
24892
24893   arg1 = (Dali::TextureSet *)jarg1;
24894   if (!arg1) {
24895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24896     return 0;
24897   }
24898   {
24899     try {
24900       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24901     } catch (std::out_of_range& e) {
24902       {
24903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24904       };
24905     } catch (std::exception& e) {
24906       {
24907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24908       };
24909     } catch (Dali::DaliException e) {
24910       {
24911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24912       };
24913     } catch (...) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24916       };
24917     }
24918   }
24919
24920   jresult = (void *)result;
24921   return jresult;
24922 }
24923
24924
24925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24926   void * jresult ;
24927   Dali::BaseHandle arg1 ;
24928   Dali::BaseHandle *argp1 ;
24929   Dali::TextureSet result;
24930
24931   argp1 = (Dali::BaseHandle *)jarg1;
24932   if (!argp1) {
24933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24934     return 0;
24935   }
24936   arg1 = *argp1;
24937   {
24938     try {
24939       result = Dali::TextureSet::DownCast(arg1);
24940     } catch (std::out_of_range& e) {
24941       {
24942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24943       };
24944     } catch (std::exception& e) {
24945       {
24946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24947       };
24948     } catch (Dali::DaliException e) {
24949       {
24950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24951       };
24952     } catch (...) {
24953       {
24954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24955       };
24956     }
24957   }
24958
24959   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24960   return jresult;
24961 }
24962
24963
24964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24965   void * jresult ;
24966   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24967   Dali::TextureSet *arg2 = 0 ;
24968   Dali::TextureSet *result = 0 ;
24969
24970   arg1 = (Dali::TextureSet *)jarg1;
24971   arg2 = (Dali::TextureSet *)jarg2;
24972   if (!arg2) {
24973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24974     return 0;
24975   }
24976   {
24977     try {
24978       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24979     } catch (std::out_of_range& e) {
24980       {
24981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24982       };
24983     } catch (std::exception& e) {
24984       {
24985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24986       };
24987     } catch (Dali::DaliException e) {
24988       {
24989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24990       };
24991     } catch (...) {
24992       {
24993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24994       };
24995     }
24996   }
24997
24998   jresult = (void *)result;
24999   return jresult;
25000 }
25001
25002
25003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25004   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25005   size_t arg2 ;
25006   Dali::Texture arg3 ;
25007   Dali::Texture *argp3 ;
25008
25009   arg1 = (Dali::TextureSet *)jarg1;
25010   arg2 = (size_t)jarg2;
25011   argp3 = (Dali::Texture *)jarg3;
25012   if (!argp3) {
25013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25014     return ;
25015   }
25016   arg3 = *argp3;
25017   {
25018     try {
25019       (arg1)->SetTexture(arg2,arg3);
25020     } catch (std::out_of_range& e) {
25021       {
25022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25023       };
25024     } catch (std::exception& e) {
25025       {
25026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25027       };
25028     } catch (Dali::DaliException e) {
25029       {
25030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25031       };
25032     } catch (...) {
25033       {
25034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25035       };
25036     }
25037   }
25038
25039 }
25040
25041
25042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25043   void * jresult ;
25044   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25045   size_t arg2 ;
25046   Dali::Texture result;
25047
25048   arg1 = (Dali::TextureSet *)jarg1;
25049   arg2 = (size_t)jarg2;
25050   {
25051     try {
25052       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25053     } catch (std::out_of_range& e) {
25054       {
25055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25056       };
25057     } catch (std::exception& e) {
25058       {
25059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25060       };
25061     } catch (Dali::DaliException e) {
25062       {
25063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25064       };
25065     } catch (...) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25068       };
25069     }
25070   }
25071
25072   jresult = new Dali::Texture((const Dali::Texture &)result);
25073   return jresult;
25074 }
25075
25076
25077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25078   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25079   size_t arg2 ;
25080   Dali::Sampler arg3 ;
25081   Dali::Sampler *argp3 ;
25082
25083   arg1 = (Dali::TextureSet *)jarg1;
25084   arg2 = (size_t)jarg2;
25085   argp3 = (Dali::Sampler *)jarg3;
25086   if (!argp3) {
25087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25088     return ;
25089   }
25090   arg3 = *argp3;
25091   {
25092     try {
25093       (arg1)->SetSampler(arg2,arg3);
25094     } catch (std::out_of_range& e) {
25095       {
25096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25097       };
25098     } catch (std::exception& e) {
25099       {
25100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25101       };
25102     } catch (Dali::DaliException e) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25109       };
25110     }
25111   }
25112
25113 }
25114
25115
25116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25117   void * jresult ;
25118   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25119   size_t arg2 ;
25120   Dali::Sampler result;
25121
25122   arg1 = (Dali::TextureSet *)jarg1;
25123   arg2 = (size_t)jarg2;
25124   {
25125     try {
25126       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25127     } catch (std::out_of_range& e) {
25128       {
25129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25130       };
25131     } catch (std::exception& e) {
25132       {
25133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25134       };
25135     } catch (Dali::DaliException e) {
25136       {
25137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25138       };
25139     } catch (...) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25142       };
25143     }
25144   }
25145
25146   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25147   return jresult;
25148 }
25149
25150
25151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25152   unsigned long jresult ;
25153   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25154   size_t result;
25155
25156   arg1 = (Dali::TextureSet *)jarg1;
25157   {
25158     try {
25159       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25160     } catch (std::out_of_range& e) {
25161       {
25162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (std::exception& e) {
25165       {
25166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25167       };
25168     } catch (Dali::DaliException e) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25171       };
25172     } catch (...) {
25173       {
25174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25175       };
25176     }
25177   }
25178
25179   jresult = (unsigned long)result;
25180   return jresult;
25181 }
25182
25183
25184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
25185   void * jresult ;
25186   Dali::Property::Map *arg1 = 0 ;
25187   Dali::VertexBuffer result;
25188
25189   arg1 = (Dali::Property::Map *)jarg1;
25190   if (!arg1) {
25191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25192     return 0;
25193   }
25194   {
25195     try {
25196       result = Dali::VertexBuffer::New(*arg1);
25197     } catch (std::out_of_range& e) {
25198       {
25199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25200       };
25201     } catch (std::exception& e) {
25202       {
25203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25204       };
25205     } catch (Dali::DaliException e) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25208       };
25209     } catch (...) {
25210       {
25211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25212       };
25213     }
25214   }
25215
25216   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
25217   return jresult;
25218 }
25219
25220
25221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
25222   void * jresult ;
25223   Dali::VertexBuffer *result = 0 ;
25224
25225   {
25226     try {
25227       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
25228     } catch (std::out_of_range& e) {
25229       {
25230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25231       };
25232     } catch (std::exception& e) {
25233       {
25234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (Dali::DaliException e) {
25237       {
25238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25239       };
25240     } catch (...) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25243       };
25244     }
25245   }
25246
25247   jresult = (void *)result;
25248   return jresult;
25249 }
25250
25251
25252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
25253   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25254
25255   arg1 = (Dali::VertexBuffer *)jarg1;
25256   {
25257     try {
25258       delete arg1;
25259     } catch (std::out_of_range& e) {
25260       {
25261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25262       };
25263     } catch (std::exception& e) {
25264       {
25265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25266       };
25267     } catch (Dali::DaliException e) {
25268       {
25269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25270       };
25271     } catch (...) {
25272       {
25273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25274       };
25275     }
25276   }
25277
25278 }
25279
25280
25281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
25282   void * jresult ;
25283   Dali::VertexBuffer *arg1 = 0 ;
25284   Dali::VertexBuffer *result = 0 ;
25285
25286   arg1 = (Dali::VertexBuffer *)jarg1;
25287   if (!arg1) {
25288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25289     return 0;
25290   }
25291   {
25292     try {
25293       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
25294     } catch (std::out_of_range& e) {
25295       {
25296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25297       };
25298     } catch (std::exception& e) {
25299       {
25300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25301       };
25302     } catch (Dali::DaliException e) {
25303       {
25304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25305       };
25306     } catch (...) {
25307       {
25308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25309       };
25310     }
25311   }
25312
25313   jresult = (void *)result;
25314   return jresult;
25315 }
25316
25317
25318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
25319   void * jresult ;
25320   Dali::BaseHandle arg1 ;
25321   Dali::BaseHandle *argp1 ;
25322   Dali::VertexBuffer result;
25323
25324   argp1 = (Dali::BaseHandle *)jarg1;
25325   if (!argp1) {
25326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25327     return 0;
25328   }
25329   arg1 = *argp1;
25330   {
25331     try {
25332       result = Dali::VertexBuffer::DownCast(arg1);
25333     } catch (std::out_of_range& e) {
25334       {
25335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25336       };
25337     } catch (std::exception& e) {
25338       {
25339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25340       };
25341     } catch (Dali::DaliException e) {
25342       {
25343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25344       };
25345     } catch (...) {
25346       {
25347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25348       };
25349     }
25350   }
25351
25352   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
25353   return jresult;
25354 }
25355
25356
25357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
25358   void * jresult ;
25359   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25360   Dali::VertexBuffer *arg2 = 0 ;
25361   Dali::VertexBuffer *result = 0 ;
25362
25363   arg1 = (Dali::VertexBuffer *)jarg1;
25364   arg2 = (Dali::VertexBuffer *)jarg2;
25365   if (!arg2) {
25366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25367     return 0;
25368   }
25369   {
25370     try {
25371       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
25372     } catch (std::out_of_range& e) {
25373       {
25374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25375       };
25376     } catch (std::exception& e) {
25377       {
25378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25379       };
25380     } catch (Dali::DaliException e) {
25381       {
25382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25383       };
25384     } catch (...) {
25385       {
25386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25387       };
25388     }
25389   }
25390
25391   jresult = (void *)result;
25392   return jresult;
25393 }
25394
25395
25396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25397   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25398   void *arg2 = (void *) 0 ;
25399   std::size_t arg3 ;
25400
25401   arg1 = (Dali::VertexBuffer *)jarg1;
25402   arg2 = jarg2;
25403   arg3 = (std::size_t)jarg3;
25404   {
25405     try {
25406       (arg1)->SetData((void const *)arg2,arg3);
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25422       };
25423     }
25424   }
25425
25426 }
25427
25428
25429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
25430   unsigned long jresult ;
25431   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25432   std::size_t result;
25433
25434   arg1 = (Dali::VertexBuffer *)jarg1;
25435   {
25436     try {
25437       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
25438     } catch (std::out_of_range& e) {
25439       {
25440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25441       };
25442     } catch (std::exception& e) {
25443       {
25444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25445       };
25446     } catch (Dali::DaliException e) {
25447       {
25448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25449       };
25450     } catch (...) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25453       };
25454     }
25455   }
25456
25457   jresult = (unsigned long)result;
25458   return jresult;
25459 }
25460
25461
25462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25463   void * jresult ;
25464   Dali::Geometry result;
25465
25466   {
25467     try {
25468       result = Dali::Geometry::New();
25469     } catch (std::out_of_range& e) {
25470       {
25471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25472       };
25473     } catch (std::exception& e) {
25474       {
25475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25476       };
25477     } catch (Dali::DaliException e) {
25478       {
25479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25480       };
25481     } catch (...) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25484       };
25485     }
25486   }
25487
25488   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25489   return jresult;
25490 }
25491
25492
25493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25494   void * jresult ;
25495   Dali::Geometry *result = 0 ;
25496
25497   {
25498     try {
25499       result = (Dali::Geometry *)new Dali::Geometry();
25500     } catch (std::out_of_range& e) {
25501       {
25502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25503       };
25504     } catch (std::exception& e) {
25505       {
25506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25507       };
25508     } catch (Dali::DaliException e) {
25509       {
25510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25511       };
25512     } catch (...) {
25513       {
25514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25515       };
25516     }
25517   }
25518
25519   jresult = (void *)result;
25520   return jresult;
25521 }
25522
25523
25524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25525   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25526
25527   arg1 = (Dali::Geometry *)jarg1;
25528   {
25529     try {
25530       delete arg1;
25531     } catch (std::out_of_range& e) {
25532       {
25533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25534       };
25535     } catch (std::exception& e) {
25536       {
25537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25538       };
25539     } catch (Dali::DaliException e) {
25540       {
25541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25542       };
25543     } catch (...) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25546       };
25547     }
25548   }
25549
25550 }
25551
25552
25553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25554   void * jresult ;
25555   Dali::Geometry *arg1 = 0 ;
25556   Dali::Geometry *result = 0 ;
25557
25558   arg1 = (Dali::Geometry *)jarg1;
25559   if (!arg1) {
25560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25561     return 0;
25562   }
25563   {
25564     try {
25565       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25566     } catch (std::out_of_range& e) {
25567       {
25568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25569       };
25570     } catch (std::exception& e) {
25571       {
25572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25573       };
25574     } catch (Dali::DaliException e) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25581       };
25582     }
25583   }
25584
25585   jresult = (void *)result;
25586   return jresult;
25587 }
25588
25589
25590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25591   void * jresult ;
25592   Dali::BaseHandle arg1 ;
25593   Dali::BaseHandle *argp1 ;
25594   Dali::Geometry result;
25595
25596   argp1 = (Dali::BaseHandle *)jarg1;
25597   if (!argp1) {
25598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25599     return 0;
25600   }
25601   arg1 = *argp1;
25602   {
25603     try {
25604       result = Dali::Geometry::DownCast(arg1);
25605     } catch (std::out_of_range& e) {
25606       {
25607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (std::exception& e) {
25610       {
25611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25612       };
25613     } catch (Dali::DaliException e) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25616       };
25617     } catch (...) {
25618       {
25619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25620       };
25621     }
25622   }
25623
25624   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25625   return jresult;
25626 }
25627
25628
25629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25630   void * jresult ;
25631   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25632   Dali::Geometry *arg2 = 0 ;
25633   Dali::Geometry *result = 0 ;
25634
25635   arg1 = (Dali::Geometry *)jarg1;
25636   arg2 = (Dali::Geometry *)jarg2;
25637   if (!arg2) {
25638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25639     return 0;
25640   }
25641   {
25642     try {
25643       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25644     } catch (std::out_of_range& e) {
25645       {
25646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25647       };
25648     } catch (std::exception& e) {
25649       {
25650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25651       };
25652     } catch (Dali::DaliException e) {
25653       {
25654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25655       };
25656     } catch (...) {
25657       {
25658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25659       };
25660     }
25661   }
25662
25663   jresult = (void *)result;
25664   return jresult;
25665 }
25666
25667
25668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25669   unsigned long jresult ;
25670   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25671   Dali::VertexBuffer *arg2 = 0 ;
25672   std::size_t result;
25673
25674   arg1 = (Dali::Geometry *)jarg1;
25675   arg2 = (Dali::VertexBuffer *)jarg2;
25676   if (!arg2) {
25677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
25678     return 0;
25679   }
25680   {
25681     try {
25682       result = (arg1)->AddVertexBuffer(*arg2);
25683     } catch (std::out_of_range& e) {
25684       {
25685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (std::exception& e) {
25688       {
25689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (Dali::DaliException e) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25698       };
25699     }
25700   }
25701
25702   jresult = (unsigned long)result;
25703   return jresult;
25704 }
25705
25706
25707 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25708   unsigned long jresult ;
25709   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25710   std::size_t result;
25711
25712   arg1 = (Dali::Geometry *)jarg1;
25713   {
25714     try {
25715       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25716     } catch (std::out_of_range& e) {
25717       {
25718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25719       };
25720     } catch (std::exception& e) {
25721       {
25722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (Dali::DaliException e) {
25725       {
25726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25727       };
25728     } catch (...) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25731       };
25732     }
25733   }
25734
25735   jresult = (unsigned long)result;
25736   return jresult;
25737 }
25738
25739
25740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25741   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25742   std::size_t arg2 ;
25743
25744   arg1 = (Dali::Geometry *)jarg1;
25745   arg2 = (std::size_t)jarg2;
25746   {
25747     try {
25748       (arg1)->RemoveVertexBuffer(arg2);
25749     } catch (std::out_of_range& e) {
25750       {
25751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25752       };
25753     } catch (std::exception& e) {
25754       {
25755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25756       };
25757     } catch (Dali::DaliException e) {
25758       {
25759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25764       };
25765     }
25766   }
25767
25768 }
25769
25770
25771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25772   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25773   unsigned short *arg2 = (unsigned short *) 0 ;
25774   size_t arg3 ;
25775
25776   arg1 = (Dali::Geometry *)jarg1;
25777   arg2 = jarg2;
25778   arg3 = (size_t)jarg3;
25779   {
25780     try {
25781       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800
25801
25802
25803 }
25804
25805
25806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25808   Dali::Geometry::Type arg2 ;
25809
25810   arg1 = (Dali::Geometry *)jarg1;
25811   arg2 = (Dali::Geometry::Type)jarg2;
25812   {
25813     try {
25814       (arg1)->SetType(arg2);
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25822       };
25823     } catch (Dali::DaliException e) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25826       };
25827     } catch (...) {
25828       {
25829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25830       };
25831     }
25832   }
25833
25834 }
25835
25836
25837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25838   int jresult ;
25839   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25840   Dali::Geometry::Type result;
25841
25842   arg1 = (Dali::Geometry *)jarg1;
25843   {
25844     try {
25845       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25846     } catch (std::out_of_range& e) {
25847       {
25848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25849       };
25850     } catch (std::exception& e) {
25851       {
25852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25853       };
25854     } catch (Dali::DaliException e) {
25855       {
25856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25857       };
25858     } catch (...) {
25859       {
25860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25861       };
25862     }
25863   }
25864
25865   jresult = (int)result;
25866   return jresult;
25867 }
25868
25869
25870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25871   void * jresult ;
25872   Dali::Shader::Hint *result = 0 ;
25873
25874   {
25875     try {
25876       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (Dali::DaliException e) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25888       };
25889     } catch (...) {
25890       {
25891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25892       };
25893     }
25894   }
25895
25896   jresult = (void *)result;
25897   return jresult;
25898 }
25899
25900
25901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25902   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25903
25904   arg1 = (Dali::Shader::Hint *)jarg1;
25905   {
25906     try {
25907       delete arg1;
25908     } catch (std::out_of_range& e) {
25909       {
25910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25911       };
25912     } catch (std::exception& e) {
25913       {
25914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25915       };
25916     } catch (Dali::DaliException e) {
25917       {
25918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25919       };
25920     } catch (...) {
25921       {
25922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25923       };
25924     }
25925   }
25926
25927 }
25928
25929
25930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25931   int jresult ;
25932   int result;
25933
25934   result = (int)Dali::Shader::Property::PROGRAM;
25935   jresult = (int)result;
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25941   void * jresult ;
25942   Dali::Shader::Property *result = 0 ;
25943
25944   {
25945     try {
25946       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25947     } catch (std::out_of_range& e) {
25948       {
25949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25950       };
25951     } catch (std::exception& e) {
25952       {
25953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25954       };
25955     } catch (Dali::DaliException e) {
25956       {
25957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25958       };
25959     } catch (...) {
25960       {
25961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25962       };
25963     }
25964   }
25965
25966   jresult = (void *)result;
25967   return jresult;
25968 }
25969
25970
25971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25972   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25973
25974   arg1 = (Dali::Shader::Property *)jarg1;
25975   {
25976     try {
25977       delete arg1;
25978     } catch (std::out_of_range& e) {
25979       {
25980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25981       };
25982     } catch (std::exception& e) {
25983       {
25984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25985       };
25986     } catch (Dali::DaliException e) {
25987       {
25988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25989       };
25990     } catch (...) {
25991       {
25992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25993       };
25994     }
25995   }
25996
25997 }
25998
25999
26000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26001   void * jresult ;
26002   std::string *arg1 = 0 ;
26003   std::string *arg2 = 0 ;
26004   Dali::Shader::Hint::Value arg3 ;
26005   Dali::Shader result;
26006
26007   if (!jarg1) {
26008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26009     return 0;
26010   }
26011   std::string arg1_str(jarg1);
26012   arg1 = &arg1_str;
26013   if (!jarg2) {
26014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26015     return 0;
26016   }
26017   std::string arg2_str(jarg2);
26018   arg2 = &arg2_str;
26019   arg3 = (Dali::Shader::Hint::Value)jarg3;
26020   {
26021     try {
26022       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26023     } catch (std::out_of_range& e) {
26024       {
26025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26026       };
26027     } catch (std::exception& e) {
26028       {
26029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26030       };
26031     } catch (Dali::DaliException e) {
26032       {
26033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26034       };
26035     } catch (...) {
26036       {
26037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26038       };
26039     }
26040   }
26041
26042   jresult = new Dali::Shader((const Dali::Shader &)result);
26043
26044   //argout typemap for const std::string&
26045
26046
26047   //argout typemap for const std::string&
26048
26049   return jresult;
26050 }
26051
26052
26053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26054   void * jresult ;
26055   std::string *arg1 = 0 ;
26056   std::string *arg2 = 0 ;
26057   Dali::Shader result;
26058
26059   if (!jarg1) {
26060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26061     return 0;
26062   }
26063   std::string arg1_str(jarg1);
26064   arg1 = &arg1_str;
26065   if (!jarg2) {
26066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26067     return 0;
26068   }
26069   std::string arg2_str(jarg2);
26070   arg2 = &arg2_str;
26071   {
26072     try {
26073       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26074     } catch (std::out_of_range& e) {
26075       {
26076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26077       };
26078     } catch (std::exception& e) {
26079       {
26080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26081       };
26082     } catch (Dali::DaliException e) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26085       };
26086     } catch (...) {
26087       {
26088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26089       };
26090     }
26091   }
26092
26093   jresult = new Dali::Shader((const Dali::Shader &)result);
26094
26095   //argout typemap for const std::string&
26096
26097
26098   //argout typemap for const std::string&
26099
26100   return jresult;
26101 }
26102
26103
26104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26105   void * jresult ;
26106   Dali::Shader *result = 0 ;
26107
26108   {
26109     try {
26110       result = (Dali::Shader *)new Dali::Shader();
26111     } catch (std::out_of_range& e) {
26112       {
26113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26114       };
26115     } catch (std::exception& e) {
26116       {
26117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26118       };
26119     } catch (Dali::DaliException e) {
26120       {
26121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26122       };
26123     } catch (...) {
26124       {
26125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26126       };
26127     }
26128   }
26129
26130   jresult = (void *)result;
26131   return jresult;
26132 }
26133
26134
26135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26136   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26137
26138   arg1 = (Dali::Shader *)jarg1;
26139   {
26140     try {
26141       delete arg1;
26142     } catch (std::out_of_range& e) {
26143       {
26144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26145       };
26146     } catch (std::exception& e) {
26147       {
26148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26149       };
26150     } catch (Dali::DaliException e) {
26151       {
26152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26153       };
26154     } catch (...) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26157       };
26158     }
26159   }
26160
26161 }
26162
26163
26164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26165   void * jresult ;
26166   Dali::Shader *arg1 = 0 ;
26167   Dali::Shader *result = 0 ;
26168
26169   arg1 = (Dali::Shader *)jarg1;
26170   if (!arg1) {
26171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26172     return 0;
26173   }
26174   {
26175     try {
26176       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26177     } catch (std::out_of_range& e) {
26178       {
26179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26180       };
26181     } catch (std::exception& e) {
26182       {
26183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26184       };
26185     } catch (Dali::DaliException e) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26188       };
26189     } catch (...) {
26190       {
26191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26192       };
26193     }
26194   }
26195
26196   jresult = (void *)result;
26197   return jresult;
26198 }
26199
26200
26201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26202   void * jresult ;
26203   Dali::BaseHandle arg1 ;
26204   Dali::BaseHandle *argp1 ;
26205   Dali::Shader result;
26206
26207   argp1 = (Dali::BaseHandle *)jarg1;
26208   if (!argp1) {
26209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26210     return 0;
26211   }
26212   arg1 = *argp1;
26213   {
26214     try {
26215       result = Dali::Shader::DownCast(arg1);
26216     } catch (std::out_of_range& e) {
26217       {
26218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26219       };
26220     } catch (std::exception& e) {
26221       {
26222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26223       };
26224     } catch (Dali::DaliException e) {
26225       {
26226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26227       };
26228     } catch (...) {
26229       {
26230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26231       };
26232     }
26233   }
26234
26235   jresult = new Dali::Shader((const Dali::Shader &)result);
26236   return jresult;
26237 }
26238
26239
26240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26241   void * jresult ;
26242   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26243   Dali::Shader *arg2 = 0 ;
26244   Dali::Shader *result = 0 ;
26245
26246   arg1 = (Dali::Shader *)jarg1;
26247   arg2 = (Dali::Shader *)jarg2;
26248   if (!arg2) {
26249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26250     return 0;
26251   }
26252   {
26253     try {
26254       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26255     } catch (std::out_of_range& e) {
26256       {
26257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (std::exception& e) {
26260       {
26261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26262       };
26263     } catch (Dali::DaliException e) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26266       };
26267     } catch (...) {
26268       {
26269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26270       };
26271     }
26272   }
26273
26274   jresult = (void *)result;
26275   return jresult;
26276 }
26277
26278
26279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26280   int jresult ;
26281   int result;
26282
26283   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26284   jresult = (int)result;
26285   return jresult;
26286 }
26287
26288
26289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26290   int jresult ;
26291   int result;
26292
26293   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26294   jresult = (int)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26300   int jresult ;
26301   int result;
26302
26303   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26304   jresult = (int)result;
26305   return jresult;
26306 }
26307
26308
26309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26310   int jresult ;
26311   int result;
26312
26313   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26314   jresult = (int)result;
26315   return jresult;
26316 }
26317
26318
26319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26320   int jresult ;
26321   int result;
26322
26323   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26324   jresult = (int)result;
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26330   int jresult ;
26331   int result;
26332
26333   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26334   jresult = (int)result;
26335   return jresult;
26336 }
26337
26338
26339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26340   int jresult ;
26341   int result;
26342
26343   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26344   jresult = (int)result;
26345   return jresult;
26346 }
26347
26348
26349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26350   int jresult ;
26351   int result;
26352
26353   result = (int)Dali::Renderer::Property::BLEND_MODE;
26354   jresult = (int)result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26360   int jresult ;
26361   int result;
26362
26363   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26364   jresult = (int)result;
26365   return jresult;
26366 }
26367
26368
26369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26370   int jresult ;
26371   int result;
26372
26373   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26374   jresult = (int)result;
26375   return jresult;
26376 }
26377
26378
26379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26380   int jresult ;
26381   int result;
26382
26383   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26384   jresult = (int)result;
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26390   int jresult ;
26391   int result;
26392
26393   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26394   jresult = (int)result;
26395   return jresult;
26396 }
26397
26398
26399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26400   int jresult ;
26401   int result;
26402
26403   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26404   jresult = (int)result;
26405   return jresult;
26406 }
26407
26408
26409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26410   int jresult ;
26411   int result;
26412
26413   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26414   jresult = (int)result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26420   int jresult ;
26421   int result;
26422
26423   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26424   jresult = (int)result;
26425   return jresult;
26426 }
26427
26428
26429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26430   int jresult ;
26431   int result;
26432
26433   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26434   jresult = (int)result;
26435   return jresult;
26436 }
26437
26438
26439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26440   int jresult ;
26441   int result;
26442
26443   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26444   jresult = (int)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26450   int jresult ;
26451   int result;
26452
26453   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26454   jresult = (int)result;
26455   return jresult;
26456 }
26457
26458
26459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26460   int jresult ;
26461   int result;
26462
26463   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26464   jresult = (int)result;
26465   return jresult;
26466 }
26467
26468
26469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26470   int jresult ;
26471   int result;
26472
26473   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26474   jresult = (int)result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26480   int jresult ;
26481   int result;
26482
26483   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26484   jresult = (int)result;
26485   return jresult;
26486 }
26487
26488
26489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26490   int jresult ;
26491   int result;
26492
26493   result = (int)Dali::Renderer::Property::RENDER_MODE;
26494   jresult = (int)result;
26495   return jresult;
26496 }
26497
26498
26499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26500   int jresult ;
26501   int result;
26502
26503   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26504   jresult = (int)result;
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26510   int jresult ;
26511   int result;
26512
26513   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26514   jresult = (int)result;
26515   return jresult;
26516 }
26517
26518
26519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26520   int jresult ;
26521   int result;
26522
26523   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26524   jresult = (int)result;
26525   return jresult;
26526 }
26527
26528
26529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26530   int jresult ;
26531   int result;
26532
26533   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26534   jresult = (int)result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26540   int jresult ;
26541   int result;
26542
26543   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26544   jresult = (int)result;
26545   return jresult;
26546 }
26547
26548
26549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26550   int jresult ;
26551   int result;
26552
26553   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26554   jresult = (int)result;
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26560   int jresult ;
26561   int result;
26562
26563   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26564   jresult = (int)result;
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26570   void * jresult ;
26571   Dali::Renderer::Property *result = 0 ;
26572
26573   {
26574     try {
26575       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26576     } catch (std::out_of_range& e) {
26577       {
26578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26579       };
26580     } catch (std::exception& e) {
26581       {
26582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26583       };
26584     } catch (Dali::DaliException e) {
26585       {
26586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26587       };
26588     } catch (...) {
26589       {
26590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26591       };
26592     }
26593   }
26594
26595   jresult = (void *)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26601   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26602
26603   arg1 = (Dali::Renderer::Property *)jarg1;
26604   {
26605     try {
26606       delete arg1;
26607     } catch (std::out_of_range& e) {
26608       {
26609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26610       };
26611     } catch (std::exception& e) {
26612       {
26613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26614       };
26615     } catch (Dali::DaliException e) {
26616       {
26617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26618       };
26619     } catch (...) {
26620       {
26621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26622       };
26623     }
26624   }
26625
26626 }
26627
26628
26629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26630   void * jresult ;
26631   Dali::Geometry *arg1 = 0 ;
26632   Dali::Shader *arg2 = 0 ;
26633   Dali::Renderer result;
26634
26635   arg1 = (Dali::Geometry *)jarg1;
26636   if (!arg1) {
26637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26638     return 0;
26639   }
26640   arg2 = (Dali::Shader *)jarg2;
26641   if (!arg2) {
26642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26643     return 0;
26644   }
26645   {
26646     try {
26647       result = Dali::Renderer::New(*arg1,*arg2);
26648     } catch (std::out_of_range& e) {
26649       {
26650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26651       };
26652     } catch (std::exception& e) {
26653       {
26654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26655       };
26656     } catch (Dali::DaliException e) {
26657       {
26658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26659       };
26660     } catch (...) {
26661       {
26662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26663       };
26664     }
26665   }
26666
26667   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26668   return jresult;
26669 }
26670
26671
26672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26673   void * jresult ;
26674   Dali::Renderer *result = 0 ;
26675
26676   {
26677     try {
26678       result = (Dali::Renderer *)new Dali::Renderer();
26679     } catch (std::out_of_range& e) {
26680       {
26681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26682       };
26683     } catch (std::exception& e) {
26684       {
26685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26686       };
26687     } catch (Dali::DaliException e) {
26688       {
26689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26690       };
26691     } catch (...) {
26692       {
26693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26694       };
26695     }
26696   }
26697
26698   jresult = (void *)result;
26699   return jresult;
26700 }
26701
26702
26703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26704   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26705
26706   arg1 = (Dali::Renderer *)jarg1;
26707   {
26708     try {
26709       delete arg1;
26710     } catch (std::out_of_range& e) {
26711       {
26712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26713       };
26714     } catch (std::exception& e) {
26715       {
26716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26717       };
26718     } catch (Dali::DaliException e) {
26719       {
26720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26721       };
26722     } catch (...) {
26723       {
26724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26725       };
26726     }
26727   }
26728
26729 }
26730
26731
26732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26733   void * jresult ;
26734   Dali::Renderer *arg1 = 0 ;
26735   Dali::Renderer *result = 0 ;
26736
26737   arg1 = (Dali::Renderer *)jarg1;
26738   if (!arg1) {
26739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26740     return 0;
26741   }
26742   {
26743     try {
26744       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26745     } catch (std::out_of_range& e) {
26746       {
26747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26748       };
26749     } catch (std::exception& e) {
26750       {
26751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26752       };
26753     } catch (Dali::DaliException e) {
26754       {
26755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26756       };
26757     } catch (...) {
26758       {
26759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26760       };
26761     }
26762   }
26763
26764   jresult = (void *)result;
26765   return jresult;
26766 }
26767
26768
26769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26770   void * jresult ;
26771   Dali::BaseHandle arg1 ;
26772   Dali::BaseHandle *argp1 ;
26773   Dali::Renderer result;
26774
26775   argp1 = (Dali::BaseHandle *)jarg1;
26776   if (!argp1) {
26777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26778     return 0;
26779   }
26780   arg1 = *argp1;
26781   {
26782     try {
26783       result = Dali::Renderer::DownCast(arg1);
26784     } catch (std::out_of_range& e) {
26785       {
26786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26787       };
26788     } catch (std::exception& e) {
26789       {
26790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26791       };
26792     } catch (Dali::DaliException e) {
26793       {
26794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26795       };
26796     } catch (...) {
26797       {
26798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26799       };
26800     }
26801   }
26802
26803   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26804   return jresult;
26805 }
26806
26807
26808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26809   void * jresult ;
26810   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26811   Dali::Renderer *arg2 = 0 ;
26812   Dali::Renderer *result = 0 ;
26813
26814   arg1 = (Dali::Renderer *)jarg1;
26815   arg2 = (Dali::Renderer *)jarg2;
26816   if (!arg2) {
26817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26818     return 0;
26819   }
26820   {
26821     try {
26822       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26823     } catch (std::out_of_range& e) {
26824       {
26825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (std::exception& e) {
26828       {
26829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26830       };
26831     } catch (Dali::DaliException e) {
26832       {
26833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26834       };
26835     } catch (...) {
26836       {
26837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26838       };
26839     }
26840   }
26841
26842   jresult = (void *)result;
26843   return jresult;
26844 }
26845
26846
26847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26848   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26849   Dali::Geometry *arg2 = 0 ;
26850
26851   arg1 = (Dali::Renderer *)jarg1;
26852   arg2 = (Dali::Geometry *)jarg2;
26853   if (!arg2) {
26854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26855     return ;
26856   }
26857   {
26858     try {
26859       (arg1)->SetGeometry(*arg2);
26860     } catch (std::out_of_range& e) {
26861       {
26862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26863       };
26864     } catch (std::exception& e) {
26865       {
26866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26867       };
26868     } catch (Dali::DaliException e) {
26869       {
26870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26871       };
26872     } catch (...) {
26873       {
26874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26875       };
26876     }
26877   }
26878
26879 }
26880
26881
26882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26883   void * jresult ;
26884   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26885   Dali::Geometry result;
26886
26887   arg1 = (Dali::Renderer *)jarg1;
26888   {
26889     try {
26890       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26891     } catch (std::out_of_range& e) {
26892       {
26893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26894       };
26895     } catch (std::exception& e) {
26896       {
26897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26898       };
26899     } catch (Dali::DaliException e) {
26900       {
26901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26902       };
26903     } catch (...) {
26904       {
26905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26906       };
26907     }
26908   }
26909
26910   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26911   return jresult;
26912 }
26913
26914
26915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26916   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26917   int arg2 ;
26918   int arg3 ;
26919
26920   arg1 = (Dali::Renderer *)jarg1;
26921   arg2 = (int)jarg2;
26922   arg3 = (int)jarg3;
26923   {
26924     try {
26925       (arg1)->SetIndexRange(arg2,arg3);
26926     } catch (std::out_of_range& e) {
26927       {
26928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26929       };
26930     } catch (std::exception& e) {
26931       {
26932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26933       };
26934     } catch (Dali::DaliException e) {
26935       {
26936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26937       };
26938     } catch (...) {
26939       {
26940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26941       };
26942     }
26943   }
26944
26945 }
26946
26947
26948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26949   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26950   Dali::TextureSet *arg2 = 0 ;
26951
26952   arg1 = (Dali::Renderer *)jarg1;
26953   arg2 = (Dali::TextureSet *)jarg2;
26954   if (!arg2) {
26955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26956     return ;
26957   }
26958   {
26959     try {
26960       (arg1)->SetTextures(*arg2);
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (Dali::DaliException e) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26972       };
26973     } catch (...) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26976       };
26977     }
26978   }
26979
26980 }
26981
26982
26983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26984   void * jresult ;
26985   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26986   Dali::TextureSet result;
26987
26988   arg1 = (Dali::Renderer *)jarg1;
26989   {
26990     try {
26991       result = ((Dali::Renderer const *)arg1)->GetTextures();
26992     } catch (std::out_of_range& e) {
26993       {
26994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26995       };
26996     } catch (std::exception& e) {
26997       {
26998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26999       };
27000     } catch (Dali::DaliException e) {
27001       {
27002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27003       };
27004     } catch (...) {
27005       {
27006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27007       };
27008     }
27009   }
27010
27011   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27012   return jresult;
27013 }
27014
27015
27016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27017   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27018   Dali::Shader *arg2 = 0 ;
27019
27020   arg1 = (Dali::Renderer *)jarg1;
27021   arg2 = (Dali::Shader *)jarg2;
27022   if (!arg2) {
27023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27024     return ;
27025   }
27026   {
27027     try {
27028       (arg1)->SetShader(*arg2);
27029     } catch (std::out_of_range& e) {
27030       {
27031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27032       };
27033     } catch (std::exception& e) {
27034       {
27035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27036       };
27037     } catch (Dali::DaliException e) {
27038       {
27039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27040       };
27041     } catch (...) {
27042       {
27043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27044       };
27045     }
27046   }
27047
27048 }
27049
27050
27051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27052   void * jresult ;
27053   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27054   Dali::Shader result;
27055
27056   arg1 = (Dali::Renderer *)jarg1;
27057   {
27058     try {
27059       result = ((Dali::Renderer const *)arg1)->GetShader();
27060     } catch (std::out_of_range& e) {
27061       {
27062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27063       };
27064     } catch (std::exception& e) {
27065       {
27066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27067       };
27068     } catch (Dali::DaliException e) {
27069       {
27070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27071       };
27072     } catch (...) {
27073       {
27074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27075       };
27076     }
27077   }
27078
27079   jresult = new Dali::Shader((const Dali::Shader &)result);
27080   return jresult;
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27085   void * jresult ;
27086   Dali::FrameBuffer::Attachment *result = 0 ;
27087
27088   {
27089     try {
27090       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27091     } catch (std::out_of_range& e) {
27092       {
27093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27094       };
27095     } catch (std::exception& e) {
27096       {
27097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (Dali::DaliException e) {
27100       {
27101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27102       };
27103     } catch (...) {
27104       {
27105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27106       };
27107     }
27108   }
27109
27110   jresult = (void *)result;
27111   return jresult;
27112 }
27113
27114
27115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27116   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27117
27118   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27119   {
27120     try {
27121       delete arg1;
27122     } catch (std::out_of_range& e) {
27123       {
27124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27125       };
27126     } catch (std::exception& e) {
27127       {
27128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27129       };
27130     } catch (Dali::DaliException e) {
27131       {
27132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27133       };
27134     } catch (...) {
27135       {
27136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27137       };
27138     }
27139   }
27140
27141 }
27142
27143
27144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27145   void * jresult ;
27146   unsigned int arg1 ;
27147   unsigned int arg2 ;
27148   unsigned int arg3 ;
27149   Dali::FrameBuffer result;
27150
27151   arg1 = (unsigned int)jarg1;
27152   arg2 = (unsigned int)jarg2;
27153   arg3 = (unsigned int)jarg3;
27154   {
27155     try {
27156       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27157     } catch (std::out_of_range& e) {
27158       {
27159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27160       };
27161     } catch (std::exception& e) {
27162       {
27163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27164       };
27165     } catch (Dali::DaliException e) {
27166       {
27167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27168       };
27169     } catch (...) {
27170       {
27171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27172       };
27173     }
27174   }
27175
27176   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27177   return jresult;
27178 }
27179
27180
27181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27182   void * jresult ;
27183   Dali::FrameBuffer *result = 0 ;
27184
27185   {
27186     try {
27187       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27188     } catch (std::out_of_range& e) {
27189       {
27190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27191       };
27192     } catch (std::exception& e) {
27193       {
27194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27195       };
27196     } catch (Dali::DaliException e) {
27197       {
27198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27199       };
27200     } catch (...) {
27201       {
27202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27203       };
27204     }
27205   }
27206
27207   jresult = (void *)result;
27208   return jresult;
27209 }
27210
27211
27212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27213   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27214
27215   arg1 = (Dali::FrameBuffer *)jarg1;
27216   {
27217     try {
27218       delete arg1;
27219     } catch (std::out_of_range& e) {
27220       {
27221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27222       };
27223     } catch (std::exception& e) {
27224       {
27225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27226       };
27227     } catch (Dali::DaliException e) {
27228       {
27229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27230       };
27231     } catch (...) {
27232       {
27233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27234       };
27235     }
27236   }
27237
27238 }
27239
27240
27241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27242   void * jresult ;
27243   Dali::FrameBuffer *arg1 = 0 ;
27244   Dali::FrameBuffer *result = 0 ;
27245
27246   arg1 = (Dali::FrameBuffer *)jarg1;
27247   if (!arg1) {
27248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27249     return 0;
27250   }
27251   {
27252     try {
27253       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27254     } catch (std::out_of_range& e) {
27255       {
27256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27257       };
27258     } catch (std::exception& e) {
27259       {
27260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27261       };
27262     } catch (Dali::DaliException e) {
27263       {
27264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27265       };
27266     } catch (...) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27269       };
27270     }
27271   }
27272
27273   jresult = (void *)result;
27274   return jresult;
27275 }
27276
27277
27278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27279   void * jresult ;
27280   Dali::BaseHandle arg1 ;
27281   Dali::BaseHandle *argp1 ;
27282   Dali::FrameBuffer result;
27283
27284   argp1 = (Dali::BaseHandle *)jarg1;
27285   if (!argp1) {
27286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27287     return 0;
27288   }
27289   arg1 = *argp1;
27290   {
27291     try {
27292       result = Dali::FrameBuffer::DownCast(arg1);
27293     } catch (std::out_of_range& e) {
27294       {
27295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (std::exception& e) {
27298       {
27299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27300       };
27301     } catch (Dali::DaliException e) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27304       };
27305     } catch (...) {
27306       {
27307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27308       };
27309     }
27310   }
27311
27312   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27313   return jresult;
27314 }
27315
27316
27317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27318   void * jresult ;
27319   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27320   Dali::FrameBuffer *arg2 = 0 ;
27321   Dali::FrameBuffer *result = 0 ;
27322
27323   arg1 = (Dali::FrameBuffer *)jarg1;
27324   arg2 = (Dali::FrameBuffer *)jarg2;
27325   if (!arg2) {
27326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27327     return 0;
27328   }
27329   {
27330     try {
27331       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27332     } catch (std::out_of_range& e) {
27333       {
27334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (std::exception& e) {
27337       {
27338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27339       };
27340     } catch (Dali::DaliException e) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27343       };
27344     } catch (...) {
27345       {
27346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27347       };
27348     }
27349   }
27350
27351   jresult = (void *)result;
27352   return jresult;
27353 }
27354
27355
27356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27357   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27358   Dali::Texture *arg2 = 0 ;
27359
27360   arg1 = (Dali::FrameBuffer *)jarg1;
27361   arg2 = (Dali::Texture *)jarg2;
27362   if (!arg2) {
27363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27364     return ;
27365   }
27366   {
27367     try {
27368       (arg1)->AttachColorTexture(*arg2);
27369     } catch (std::out_of_range& e) {
27370       {
27371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27372       };
27373     } catch (std::exception& e) {
27374       {
27375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27376       };
27377     } catch (Dali::DaliException e) {
27378       {
27379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27380       };
27381     } catch (...) {
27382       {
27383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27384       };
27385     }
27386   }
27387
27388 }
27389
27390
27391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27392   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27393   Dali::Texture *arg2 = 0 ;
27394   unsigned int arg3 ;
27395   unsigned int arg4 ;
27396
27397   arg1 = (Dali::FrameBuffer *)jarg1;
27398   arg2 = (Dali::Texture *)jarg2;
27399   if (!arg2) {
27400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27401     return ;
27402   }
27403   arg3 = (unsigned int)jarg3;
27404   arg4 = (unsigned int)jarg4;
27405   {
27406     try {
27407       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27408     } catch (std::out_of_range& e) {
27409       {
27410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27411       };
27412     } catch (std::exception& e) {
27413       {
27414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27415       };
27416     } catch (Dali::DaliException e) {
27417       {
27418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27419       };
27420     } catch (...) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27423       };
27424     }
27425   }
27426
27427 }
27428
27429
27430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27431   void * jresult ;
27432   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27433   Dali::Texture result;
27434
27435   arg1 = (Dali::FrameBuffer *)jarg1;
27436   {
27437     try {
27438       result = (arg1)->GetColorTexture();
27439     } catch (std::out_of_range& e) {
27440       {
27441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27442       };
27443     } catch (std::exception& e) {
27444       {
27445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27446       };
27447     } catch (Dali::DaliException e) {
27448       {
27449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27450       };
27451     } catch (...) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27454       };
27455     }
27456   }
27457
27458   jresult = new Dali::Texture((const Dali::Texture &)result);
27459   return jresult;
27460 }
27461
27462
27463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27464   void * jresult ;
27465   Dali::RenderTaskList *result = 0 ;
27466
27467   {
27468     try {
27469       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27470     } catch (std::out_of_range& e) {
27471       {
27472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27473       };
27474     } catch (std::exception& e) {
27475       {
27476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27477       };
27478     } catch (Dali::DaliException e) {
27479       {
27480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27481       };
27482     } catch (...) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27485       };
27486     }
27487   }
27488
27489   jresult = (void *)result;
27490   return jresult;
27491 }
27492
27493
27494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27495   void * jresult ;
27496   Dali::BaseHandle arg1 ;
27497   Dali::BaseHandle *argp1 ;
27498   Dali::RenderTaskList result;
27499
27500   argp1 = (Dali::BaseHandle *)jarg1;
27501   if (!argp1) {
27502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27503     return 0;
27504   }
27505   arg1 = *argp1;
27506   {
27507     try {
27508       result = Dali::RenderTaskList::DownCast(arg1);
27509     } catch (std::out_of_range& e) {
27510       {
27511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (std::exception& e) {
27514       {
27515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (Dali::DaliException e) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527
27528   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27529   return jresult;
27530 }
27531
27532
27533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27534   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27535
27536   arg1 = (Dali::RenderTaskList *)jarg1;
27537   {
27538     try {
27539       delete arg1;
27540     } catch (std::out_of_range& e) {
27541       {
27542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27543       };
27544     } catch (std::exception& e) {
27545       {
27546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27547       };
27548     } catch (Dali::DaliException e) {
27549       {
27550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27551       };
27552     } catch (...) {
27553       {
27554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27555       };
27556     }
27557   }
27558
27559 }
27560
27561
27562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27563   void * jresult ;
27564   Dali::RenderTaskList *arg1 = 0 ;
27565   Dali::RenderTaskList *result = 0 ;
27566
27567   arg1 = (Dali::RenderTaskList *)jarg1;
27568   if (!arg1) {
27569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27570     return 0;
27571   }
27572   {
27573     try {
27574       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27575     } catch (std::out_of_range& e) {
27576       {
27577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27578       };
27579     } catch (std::exception& e) {
27580       {
27581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27582       };
27583     } catch (Dali::DaliException e) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27586       };
27587     } catch (...) {
27588       {
27589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27590       };
27591     }
27592   }
27593
27594   jresult = (void *)result;
27595   return jresult;
27596 }
27597
27598
27599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27600   void * jresult ;
27601   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27602   Dali::RenderTaskList *arg2 = 0 ;
27603   Dali::RenderTaskList *result = 0 ;
27604
27605   arg1 = (Dali::RenderTaskList *)jarg1;
27606   arg2 = (Dali::RenderTaskList *)jarg2;
27607   if (!arg2) {
27608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27609     return 0;
27610   }
27611   {
27612     try {
27613       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27614     } catch (std::out_of_range& e) {
27615       {
27616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27617       };
27618     } catch (std::exception& e) {
27619       {
27620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27621       };
27622     } catch (Dali::DaliException e) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27625       };
27626     } catch (...) {
27627       {
27628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27629       };
27630     }
27631   }
27632
27633   jresult = (void *)result;
27634   return jresult;
27635 }
27636
27637
27638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27639   void * jresult ;
27640   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27641   Dali::RenderTask result;
27642
27643   arg1 = (Dali::RenderTaskList *)jarg1;
27644   {
27645     try {
27646       result = (arg1)->CreateTask();
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 (Dali::DaliException e) {
27656       {
27657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27658       };
27659     } catch (...) {
27660       {
27661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27662       };
27663     }
27664   }
27665
27666   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27667   return jresult;
27668 }
27669
27670
27671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27672   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27673   Dali::RenderTask arg2 ;
27674   Dali::RenderTask *argp2 ;
27675
27676   arg1 = (Dali::RenderTaskList *)jarg1;
27677   argp2 = (Dali::RenderTask *)jarg2;
27678   if (!argp2) {
27679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27680     return ;
27681   }
27682   arg2 = *argp2;
27683   {
27684     try {
27685       (arg1)->RemoveTask(arg2);
27686     } catch (std::out_of_range& e) {
27687       {
27688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27689       };
27690     } catch (std::exception& e) {
27691       {
27692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27693       };
27694     } catch (Dali::DaliException e) {
27695       {
27696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27697       };
27698     } catch (...) {
27699       {
27700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27701       };
27702     }
27703   }
27704
27705 }
27706
27707
27708 //// ===============================================end part 1 =================
27709
27710 //// ========================= part 2 ===============================
27711
27712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27713   unsigned int jresult ;
27714   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27715   unsigned int result;
27716
27717   arg1 = (Dali::RenderTaskList *)jarg1;
27718   {
27719     try {
27720       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27721     } catch (std::out_of_range& e) {
27722       {
27723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27724       };
27725     } catch (std::exception& e) {
27726       {
27727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (Dali::DaliException e) {
27730       {
27731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27732       };
27733     } catch (...) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27736       };
27737     }
27738   }
27739
27740   jresult = result;
27741   return jresult;
27742 }
27743
27744
27745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27746   void * jresult ;
27747   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27748   unsigned int arg2 ;
27749   Dali::RenderTask result;
27750
27751   arg1 = (Dali::RenderTaskList *)jarg1;
27752   arg2 = (unsigned int)jarg2;
27753   {
27754     try {
27755       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27756     } catch (std::out_of_range& e) {
27757       {
27758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (std::exception& e) {
27761       {
27762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27763       };
27764     } catch (Dali::DaliException e) {
27765       {
27766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27767       };
27768     } catch (...) {
27769       {
27770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27771       };
27772     }
27773   }
27774
27775   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27776   return jresult;
27777 }
27778
27779
27780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27781   int jresult ;
27782   int result;
27783
27784   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27785   jresult = (int)result;
27786   return jresult;
27787 }
27788
27789
27790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27791   int jresult ;
27792   int result;
27793
27794   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27795   jresult = (int)result;
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27801   int jresult ;
27802   int result;
27803
27804   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27805   jresult = (int)result;
27806   return jresult;
27807 }
27808
27809
27810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27811   int jresult ;
27812   int result;
27813
27814   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27815   jresult = (int)result;
27816   return jresult;
27817 }
27818
27819
27820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27821   void * jresult ;
27822   Dali::RenderTask::Property *result = 0 ;
27823
27824   {
27825     try {
27826       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27827     } catch (std::out_of_range& e) {
27828       {
27829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27830       };
27831     } catch (std::exception& e) {
27832       {
27833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27834       };
27835     } catch (Dali::DaliException e) {
27836       {
27837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27838       };
27839     } catch (...) {
27840       {
27841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27842       };
27843     }
27844   }
27845
27846   jresult = (void *)result;
27847   return jresult;
27848 }
27849
27850
27851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27852   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27853
27854   arg1 = (Dali::RenderTask::Property *)jarg1;
27855   {
27856     try {
27857       delete arg1;
27858     } catch (std::out_of_range& e) {
27859       {
27860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27861       };
27862     } catch (std::exception& e) {
27863       {
27864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27865       };
27866     } catch (Dali::DaliException e) {
27867       {
27868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27869       };
27870     } catch (...) {
27871       {
27872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27873       };
27874     }
27875   }
27876
27877 }
27878
27879
27880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27881   void * jresult ;
27882   bool (*result)(Dali::Vector2 &) = 0 ;
27883
27884   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27885   jresult = (void *)result;
27886   return jresult;
27887 }
27888
27889
27890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27891   void * jresult ;
27892   bool (*result)(Dali::Vector2 &) = 0 ;
27893
27894   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27895   jresult = (void *)result;
27896   return jresult;
27897 }
27898
27899
27900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27901   unsigned int jresult ;
27902   bool result;
27903
27904   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27905   jresult = result;
27906   return jresult;
27907 }
27908
27909
27910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27911   unsigned int jresult ;
27912   bool result;
27913
27914   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27915   jresult = result;
27916   return jresult;
27917 }
27918
27919
27920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27921   void * jresult ;
27922   Dali::Vector4 *result = 0 ;
27923
27924   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27925   jresult = (void *)result;
27926   return jresult;
27927 }
27928
27929
27930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27931   unsigned int jresult ;
27932   bool result;
27933
27934   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27935   jresult = result;
27936   return jresult;
27937 }
27938
27939
27940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27941   unsigned int jresult ;
27942   bool result;
27943
27944   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27945   jresult = result;
27946   return jresult;
27947 }
27948
27949
27950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27951   unsigned int jresult ;
27952   unsigned int result;
27953
27954   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27955   jresult = result;
27956   return jresult;
27957 }
27958
27959
27960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27961   void * jresult ;
27962   Dali::RenderTask *result = 0 ;
27963
27964   {
27965     try {
27966       result = (Dali::RenderTask *)new Dali::RenderTask();
27967     } catch (std::out_of_range& e) {
27968       {
27969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27970       };
27971     } catch (std::exception& e) {
27972       {
27973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27974       };
27975     } catch (Dali::DaliException e) {
27976       {
27977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27978       };
27979     } catch (...) {
27980       {
27981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27982       };
27983     }
27984   }
27985
27986   jresult = (void *)result;
27987   return jresult;
27988 }
27989
27990
27991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27992   void * jresult ;
27993   Dali::BaseHandle arg1 ;
27994   Dali::BaseHandle *argp1 ;
27995   Dali::RenderTask result;
27996
27997   argp1 = (Dali::BaseHandle *)jarg1;
27998   if (!argp1) {
27999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28000     return 0;
28001   }
28002   arg1 = *argp1;
28003   {
28004     try {
28005       result = Dali::RenderTask::DownCast(arg1);
28006     } catch (std::out_of_range& e) {
28007       {
28008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28009       };
28010     } catch (std::exception& e) {
28011       {
28012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28013       };
28014     } catch (Dali::DaliException e) {
28015       {
28016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28017       };
28018     } catch (...) {
28019       {
28020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28021       };
28022     }
28023   }
28024
28025   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28026   return jresult;
28027 }
28028
28029
28030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28032
28033   arg1 = (Dali::RenderTask *)jarg1;
28034   {
28035     try {
28036       delete arg1;
28037     } catch (std::out_of_range& e) {
28038       {
28039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28040       };
28041     } catch (std::exception& e) {
28042       {
28043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28044       };
28045     } catch (Dali::DaliException e) {
28046       {
28047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28048       };
28049     } catch (...) {
28050       {
28051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28052       };
28053     }
28054   }
28055
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28060   void * jresult ;
28061   Dali::RenderTask *arg1 = 0 ;
28062   Dali::RenderTask *result = 0 ;
28063
28064   arg1 = (Dali::RenderTask *)jarg1;
28065   if (!arg1) {
28066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28067     return 0;
28068   }
28069   {
28070     try {
28071       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28072     } catch (std::out_of_range& e) {
28073       {
28074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28075       };
28076     } catch (std::exception& e) {
28077       {
28078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28079       };
28080     } catch (Dali::DaliException e) {
28081       {
28082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28083       };
28084     } catch (...) {
28085       {
28086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28087       };
28088     }
28089   }
28090
28091   jresult = (void *)result;
28092   return jresult;
28093 }
28094
28095
28096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28097   void * jresult ;
28098   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28099   Dali::RenderTask *arg2 = 0 ;
28100   Dali::RenderTask *result = 0 ;
28101
28102   arg1 = (Dali::RenderTask *)jarg1;
28103   arg2 = (Dali::RenderTask *)jarg2;
28104   if (!arg2) {
28105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28106     return 0;
28107   }
28108   {
28109     try {
28110       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28111     } catch (std::out_of_range& e) {
28112       {
28113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28114       };
28115     } catch (std::exception& e) {
28116       {
28117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28118       };
28119     } catch (Dali::DaliException e) {
28120       {
28121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28122       };
28123     } catch (...) {
28124       {
28125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28126       };
28127     }
28128   }
28129
28130   jresult = (void *)result;
28131   return jresult;
28132 }
28133
28134
28135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28136   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28137   Dali::Actor arg2 ;
28138   Dali::Actor *argp2 ;
28139
28140   arg1 = (Dali::RenderTask *)jarg1;
28141   argp2 = (Dali::Actor *)jarg2;
28142   if (!argp2) {
28143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28144     return ;
28145   }
28146   arg2 = *argp2;
28147   {
28148     try {
28149       (arg1)->SetSourceActor(arg2);
28150     } catch (std::out_of_range& e) {
28151       {
28152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28153       };
28154     } catch (std::exception& e) {
28155       {
28156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28157       };
28158     } catch (Dali::DaliException e) {
28159       {
28160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28161       };
28162     } catch (...) {
28163       {
28164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28165       };
28166     }
28167   }
28168
28169 }
28170
28171
28172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28173   void * jresult ;
28174   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28175   Dali::Actor result;
28176
28177   arg1 = (Dali::RenderTask *)jarg1;
28178   {
28179     try {
28180       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28181     } catch (std::out_of_range& e) {
28182       {
28183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28184       };
28185     } catch (std::exception& e) {
28186       {
28187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28188       };
28189     } catch (Dali::DaliException e) {
28190       {
28191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28192       };
28193     } catch (...) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28196       };
28197     }
28198   }
28199
28200   jresult = new Dali::Actor((const Dali::Actor &)result);
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28206   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28207   bool arg2 ;
28208
28209   arg1 = (Dali::RenderTask *)jarg1;
28210   arg2 = jarg2 ? true : false;
28211   {
28212     try {
28213       (arg1)->SetExclusive(arg2);
28214     } catch (std::out_of_range& e) {
28215       {
28216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28217       };
28218     } catch (std::exception& e) {
28219       {
28220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28221       };
28222     } catch (Dali::DaliException e) {
28223       {
28224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28225       };
28226     } catch (...) {
28227       {
28228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28229       };
28230     }
28231   }
28232
28233 }
28234
28235
28236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28237   unsigned int jresult ;
28238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28239   bool result;
28240
28241   arg1 = (Dali::RenderTask *)jarg1;
28242   {
28243     try {
28244       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28245     } catch (std::out_of_range& e) {
28246       {
28247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28248       };
28249     } catch (std::exception& e) {
28250       {
28251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28252       };
28253     } catch (Dali::DaliException e) {
28254       {
28255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28256       };
28257     } catch (...) {
28258       {
28259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28260       };
28261     }
28262   }
28263
28264   jresult = result;
28265   return jresult;
28266 }
28267
28268
28269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28270   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28271   bool arg2 ;
28272
28273   arg1 = (Dali::RenderTask *)jarg1;
28274   arg2 = jarg2 ? true : false;
28275   {
28276     try {
28277       (arg1)->SetInputEnabled(arg2);
28278     } catch (std::out_of_range& e) {
28279       {
28280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28281       };
28282     } catch (std::exception& e) {
28283       {
28284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28285       };
28286     } catch (Dali::DaliException e) {
28287       {
28288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28289       };
28290     } catch (...) {
28291       {
28292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28293       };
28294     }
28295   }
28296
28297 }
28298
28299
28300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28301   unsigned int jresult ;
28302   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28303   bool result;
28304
28305   arg1 = (Dali::RenderTask *)jarg1;
28306   {
28307     try {
28308       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28309     } catch (std::out_of_range& e) {
28310       {
28311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28312       };
28313     } catch (std::exception& e) {
28314       {
28315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (Dali::DaliException e) {
28318       {
28319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28320       };
28321     } catch (...) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28324       };
28325     }
28326   }
28327
28328   jresult = result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28335   Dali::CameraActor arg2 ;
28336   Dali::CameraActor *argp2 ;
28337
28338   arg1 = (Dali::RenderTask *)jarg1;
28339   argp2 = (Dali::CameraActor *)jarg2;
28340   if (!argp2) {
28341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28342     return ;
28343   }
28344   arg2 = *argp2;
28345   {
28346     try {
28347       (arg1)->SetCameraActor(arg2);
28348     } catch (std::out_of_range& e) {
28349       {
28350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28351       };
28352     } catch (std::exception& e) {
28353       {
28354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (Dali::DaliException e) {
28357       {
28358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28359       };
28360     } catch (...) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28363       };
28364     }
28365   }
28366
28367 }
28368
28369
28370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28371   void * jresult ;
28372   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28373   Dali::CameraActor result;
28374
28375   arg1 = (Dali::RenderTask *)jarg1;
28376   {
28377     try {
28378       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28379     } catch (std::out_of_range& e) {
28380       {
28381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28382       };
28383     } catch (std::exception& e) {
28384       {
28385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (Dali::DaliException e) {
28388       {
28389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28390       };
28391     } catch (...) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28394       };
28395     }
28396   }
28397
28398   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28399   return jresult;
28400 }
28401
28402
28403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28405   Dali::FrameBuffer arg2 ;
28406   Dali::FrameBuffer *argp2 ;
28407
28408   arg1 = (Dali::RenderTask *)jarg1;
28409   argp2 = (Dali::FrameBuffer *)jarg2;
28410   if (!argp2) {
28411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28412     return ;
28413   }
28414   arg2 = *argp2;
28415   {
28416     try {
28417       (arg1)->SetFrameBuffer(arg2);
28418     } catch (std::out_of_range& e) {
28419       {
28420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28421       };
28422     } catch (std::exception& e) {
28423       {
28424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28425       };
28426     } catch (Dali::DaliException e) {
28427       {
28428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28429       };
28430     } catch (...) {
28431       {
28432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28433       };
28434     }
28435   }
28436
28437 }
28438
28439
28440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28441   void * jresult ;
28442   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28443   Dali::FrameBuffer result;
28444
28445   arg1 = (Dali::RenderTask *)jarg1;
28446   {
28447     try {
28448       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28449     } catch (std::out_of_range& e) {
28450       {
28451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28452       };
28453     } catch (std::exception& e) {
28454       {
28455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28456       };
28457     } catch (Dali::DaliException e) {
28458       {
28459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28460       };
28461     } catch (...) {
28462       {
28463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28464       };
28465     }
28466   }
28467
28468   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28469   return jresult;
28470 }
28471
28472
28473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28474   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28475   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28476
28477   arg1 = (Dali::RenderTask *)jarg1;
28478   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28479   {
28480     try {
28481       (arg1)->SetScreenToFrameBufferFunction(arg2);
28482     } catch (std::out_of_range& e) {
28483       {
28484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28485       };
28486     } catch (std::exception& e) {
28487       {
28488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28489       };
28490     } catch (Dali::DaliException e) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28493       };
28494     } catch (...) {
28495       {
28496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28497       };
28498     }
28499   }
28500
28501 }
28502
28503
28504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28505   void * jresult ;
28506   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28507   Dali::RenderTask::ScreenToFrameBufferFunction result;
28508
28509   arg1 = (Dali::RenderTask *)jarg1;
28510   {
28511     try {
28512       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28513     } catch (std::out_of_range& e) {
28514       {
28515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28516       };
28517     } catch (std::exception& e) {
28518       {
28519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28520       };
28521     } catch (Dali::DaliException e) {
28522       {
28523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28524       };
28525     } catch (...) {
28526       {
28527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28528       };
28529     }
28530   }
28531
28532   jresult = (void *)result;
28533   return jresult;
28534 }
28535
28536
28537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28538   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28539   Dali::Actor arg2 ;
28540   Dali::Actor *argp2 ;
28541
28542   arg1 = (Dali::RenderTask *)jarg1;
28543   argp2 = (Dali::Actor *)jarg2;
28544   if (!argp2) {
28545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28546     return ;
28547   }
28548   arg2 = *argp2;
28549   {
28550     try {
28551       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28552     } catch (std::out_of_range& e) {
28553       {
28554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28555       };
28556     } catch (std::exception& e) {
28557       {
28558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28559       };
28560     } catch (Dali::DaliException e) {
28561       {
28562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28563       };
28564     } catch (...) {
28565       {
28566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28567       };
28568     }
28569   }
28570
28571 }
28572
28573
28574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28575   void * jresult ;
28576   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28577   Dali::Actor result;
28578
28579   arg1 = (Dali::RenderTask *)jarg1;
28580   {
28581     try {
28582       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28583     } catch (std::out_of_range& e) {
28584       {
28585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28586       };
28587     } catch (std::exception& e) {
28588       {
28589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28590       };
28591     } catch (Dali::DaliException e) {
28592       {
28593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28594       };
28595     } catch (...) {
28596       {
28597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28598       };
28599     }
28600   }
28601
28602   jresult = new Dali::Actor((const Dali::Actor &)result);
28603   return jresult;
28604 }
28605
28606
28607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28608   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28609   Dali::Vector2 arg2 ;
28610   Dali::Vector2 *argp2 ;
28611
28612   arg1 = (Dali::RenderTask *)jarg1;
28613   argp2 = (Dali::Vector2 *)jarg2;
28614   if (!argp2) {
28615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28616     return ;
28617   }
28618   arg2 = *argp2;
28619   {
28620     try {
28621       (arg1)->SetViewportPosition(arg2);
28622     } catch (std::out_of_range& e) {
28623       {
28624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28625       };
28626     } catch (std::exception& e) {
28627       {
28628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28629       };
28630     } catch (Dali::DaliException e) {
28631       {
28632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28633       };
28634     } catch (...) {
28635       {
28636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28637       };
28638     }
28639   }
28640
28641 }
28642
28643
28644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28645   void * jresult ;
28646   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28647   Dali::Vector2 result;
28648
28649   arg1 = (Dali::RenderTask *)jarg1;
28650   {
28651     try {
28652       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28653     } catch (std::out_of_range& e) {
28654       {
28655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28656       };
28657     } catch (std::exception& e) {
28658       {
28659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28660       };
28661     } catch (Dali::DaliException e) {
28662       {
28663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28664       };
28665     } catch (...) {
28666       {
28667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28668       };
28669     }
28670   }
28671
28672   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28673   return jresult;
28674 }
28675
28676
28677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28678   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28679   Dali::Vector2 arg2 ;
28680   Dali::Vector2 *argp2 ;
28681
28682   arg1 = (Dali::RenderTask *)jarg1;
28683   argp2 = (Dali::Vector2 *)jarg2;
28684   if (!argp2) {
28685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28686     return ;
28687   }
28688   arg2 = *argp2;
28689   {
28690     try {
28691       (arg1)->SetViewportSize(arg2);
28692     } catch (std::out_of_range& e) {
28693       {
28694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28695       };
28696     } catch (std::exception& e) {
28697       {
28698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28699       };
28700     } catch (Dali::DaliException e) {
28701       {
28702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28703       };
28704     } catch (...) {
28705       {
28706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28707       };
28708     }
28709   }
28710
28711 }
28712
28713
28714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28715   void * jresult ;
28716   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28717   Dali::Vector2 result;
28718
28719   arg1 = (Dali::RenderTask *)jarg1;
28720   {
28721     try {
28722       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28723     } catch (std::out_of_range& e) {
28724       {
28725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28726       };
28727     } catch (std::exception& e) {
28728       {
28729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28730       };
28731     } catch (Dali::DaliException e) {
28732       {
28733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28734       };
28735     } catch (...) {
28736       {
28737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28738       };
28739     }
28740   }
28741
28742   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28743   return jresult;
28744 }
28745
28746
28747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28748   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28749   Dali::Viewport arg2 ;
28750   Dali::Viewport *argp2 ;
28751
28752   arg1 = (Dali::RenderTask *)jarg1;
28753   argp2 = (Dali::Viewport *)jarg2;
28754   if (!argp2) {
28755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28756     return ;
28757   }
28758   arg2 = *argp2;
28759   {
28760     try {
28761       (arg1)->SetViewport(arg2);
28762     } catch (std::out_of_range& e) {
28763       {
28764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28765       };
28766     } catch (std::exception& e) {
28767       {
28768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28769       };
28770     } catch (Dali::DaliException e) {
28771       {
28772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28773       };
28774     } catch (...) {
28775       {
28776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28777       };
28778     }
28779   }
28780
28781 }
28782
28783
28784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28785   void * jresult ;
28786   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28787   Dali::Viewport result;
28788
28789   arg1 = (Dali::RenderTask *)jarg1;
28790   {
28791     try {
28792       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28793     } catch (std::out_of_range& e) {
28794       {
28795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28796       };
28797     } catch (std::exception& e) {
28798       {
28799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28800       };
28801     } catch (Dali::DaliException e) {
28802       {
28803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28804       };
28805     } catch (...) {
28806       {
28807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28808       };
28809     }
28810   }
28811
28812   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28813   return jresult;
28814 }
28815
28816
28817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28818   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28819   Dali::Vector4 *arg2 = 0 ;
28820
28821   arg1 = (Dali::RenderTask *)jarg1;
28822   arg2 = (Dali::Vector4 *)jarg2;
28823   if (!arg2) {
28824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28825     return ;
28826   }
28827   {
28828     try {
28829       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28830     } catch (std::out_of_range& e) {
28831       {
28832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28833       };
28834     } catch (std::exception& e) {
28835       {
28836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28837       };
28838     } catch (Dali::DaliException e) {
28839       {
28840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28841       };
28842     } catch (...) {
28843       {
28844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28845       };
28846     }
28847   }
28848
28849 }
28850
28851
28852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28853   void * jresult ;
28854   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28855   Dali::Vector4 result;
28856
28857   arg1 = (Dali::RenderTask *)jarg1;
28858   {
28859     try {
28860       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28861     } catch (std::out_of_range& e) {
28862       {
28863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28864       };
28865     } catch (std::exception& e) {
28866       {
28867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28868       };
28869     } catch (Dali::DaliException e) {
28870       {
28871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28872       };
28873     } catch (...) {
28874       {
28875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28876       };
28877     }
28878   }
28879
28880   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28881   return jresult;
28882 }
28883
28884
28885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28886   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28887   bool arg2 ;
28888
28889   arg1 = (Dali::RenderTask *)jarg1;
28890   arg2 = jarg2 ? true : false;
28891   {
28892     try {
28893       (arg1)->SetClearEnabled(arg2);
28894     } catch (std::out_of_range& e) {
28895       {
28896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (std::exception& e) {
28899       {
28900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28901       };
28902     } catch (Dali::DaliException e) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28905       };
28906     } catch (...) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28909       };
28910     }
28911   }
28912
28913 }
28914
28915
28916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28917   unsigned int jresult ;
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   bool result;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   {
28923     try {
28924       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28925     } catch (std::out_of_range& e) {
28926       {
28927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (std::exception& e) {
28930       {
28931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28932       };
28933     } catch (Dali::DaliException e) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28936       };
28937     } catch (...) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28940       };
28941     }
28942   }
28943
28944   jresult = result;
28945   return jresult;
28946 }
28947
28948
28949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   bool arg2 ;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   arg2 = jarg2 ? true : false;
28955   {
28956     try {
28957       (arg1)->SetCullMode(arg2);
28958     } catch (std::out_of_range& e) {
28959       {
28960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28961       };
28962     } catch (std::exception& e) {
28963       {
28964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28965       };
28966     } catch (Dali::DaliException e) {
28967       {
28968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28969       };
28970     } catch (...) {
28971       {
28972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28973       };
28974     }
28975   }
28976
28977 }
28978
28979
28980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28981   unsigned int jresult ;
28982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28983   bool result;
28984
28985   arg1 = (Dali::RenderTask *)jarg1;
28986   {
28987     try {
28988       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28989     } catch (std::out_of_range& e) {
28990       {
28991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28992       };
28993     } catch (std::exception& e) {
28994       {
28995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28996       };
28997     } catch (Dali::DaliException e) {
28998       {
28999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29000       };
29001     } catch (...) {
29002       {
29003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29004       };
29005     }
29006   }
29007
29008   jresult = result;
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29015   unsigned int arg2 ;
29016
29017   arg1 = (Dali::RenderTask *)jarg1;
29018   arg2 = (unsigned int)jarg2;
29019   {
29020     try {
29021       (arg1)->SetRefreshRate(arg2);
29022     } catch (std::out_of_range& e) {
29023       {
29024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29025       };
29026     } catch (std::exception& e) {
29027       {
29028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29029       };
29030     } catch (Dali::DaliException e) {
29031       {
29032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29033       };
29034     } catch (...) {
29035       {
29036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29037       };
29038     }
29039   }
29040
29041 }
29042
29043
29044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29045   unsigned int jresult ;
29046   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29047   unsigned int result;
29048
29049   arg1 = (Dali::RenderTask *)jarg1;
29050   {
29051     try {
29052       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
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 (Dali::DaliException e) {
29062       {
29063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29064       };
29065     } catch (...) {
29066       {
29067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29068       };
29069     }
29070   }
29071
29072   jresult = result;
29073   return jresult;
29074 }
29075
29076
29077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29078   unsigned int jresult ;
29079   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29080   Dali::Vector3 *arg2 = 0 ;
29081   float *arg3 = 0 ;
29082   float *arg4 = 0 ;
29083   bool result;
29084
29085   arg1 = (Dali::RenderTask *)jarg1;
29086   arg2 = (Dali::Vector3 *)jarg2;
29087   if (!arg2) {
29088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29089     return 0;
29090   }
29091   arg3 = (float *)jarg3;
29092   arg4 = (float *)jarg4;
29093   {
29094     try {
29095       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29096     } catch (std::out_of_range& e) {
29097       {
29098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29099       };
29100     } catch (std::exception& e) {
29101       {
29102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29103       };
29104     } catch (Dali::DaliException e) {
29105       {
29106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29107       };
29108     } catch (...) {
29109       {
29110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29111       };
29112     }
29113   }
29114
29115   jresult = result;
29116   return jresult;
29117 }
29118
29119
29120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29121   unsigned int jresult ;
29122   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29123   Dali::Actor arg2 ;
29124   float arg3 ;
29125   float arg4 ;
29126   float *arg5 = 0 ;
29127   float *arg6 = 0 ;
29128   Dali::Actor *argp2 ;
29129   bool result;
29130
29131   arg1 = (Dali::RenderTask *)jarg1;
29132   argp2 = (Dali::Actor *)jarg2;
29133   if (!argp2) {
29134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29135     return 0;
29136   }
29137   arg2 = *argp2;
29138   arg3 = (float)jarg3;
29139   arg4 = (float)jarg4;
29140   arg5 = (float *)jarg5;
29141   arg6 = (float *)jarg6;
29142   {
29143     try {
29144       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29145     } catch (std::out_of_range& e) {
29146       {
29147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29148       };
29149     } catch (std::exception& e) {
29150       {
29151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29152       };
29153     } catch (Dali::DaliException e) {
29154       {
29155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29156       };
29157     } catch (...) {
29158       {
29159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29160       };
29161     }
29162   }
29163
29164   jresult = result;
29165   return jresult;
29166 }
29167
29168
29169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29170   void * jresult ;
29171   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29172   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29173
29174   arg1 = (Dali::RenderTask *)jarg1;
29175   {
29176     try {
29177       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29178     } catch (std::out_of_range& e) {
29179       {
29180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29181       };
29182     } catch (std::exception& e) {
29183       {
29184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29185       };
29186     } catch (Dali::DaliException e) {
29187       {
29188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29189       };
29190     } catch (...) {
29191       {
29192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29193       };
29194     }
29195   }
29196
29197   jresult = (void *)result;
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29203   void * jresult ;
29204   int arg1 ;
29205   Dali::TouchPoint::State arg2 ;
29206   float arg3 ;
29207   float arg4 ;
29208   Dali::TouchPoint *result = 0 ;
29209
29210   arg1 = (int)jarg1;
29211   arg2 = (Dali::TouchPoint::State)jarg2;
29212   arg3 = (float)jarg3;
29213   arg4 = (float)jarg4;
29214   {
29215     try {
29216       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29217     } catch (std::out_of_range& e) {
29218       {
29219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29220       };
29221     } catch (std::exception& e) {
29222       {
29223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29224       };
29225     } catch (Dali::DaliException e) {
29226       {
29227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29228       };
29229     } catch (...) {
29230       {
29231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29232       };
29233     }
29234   }
29235
29236   jresult = (void *)result;
29237   return jresult;
29238 }
29239
29240
29241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29242   void * jresult ;
29243   int arg1 ;
29244   Dali::TouchPoint::State arg2 ;
29245   float arg3 ;
29246   float arg4 ;
29247   float arg5 ;
29248   float arg6 ;
29249   Dali::TouchPoint *result = 0 ;
29250
29251   arg1 = (int)jarg1;
29252   arg2 = (Dali::TouchPoint::State)jarg2;
29253   arg3 = (float)jarg3;
29254   arg4 = (float)jarg4;
29255   arg5 = (float)jarg5;
29256   arg6 = (float)jarg6;
29257   {
29258     try {
29259       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29260     } catch (std::out_of_range& e) {
29261       {
29262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (std::exception& e) {
29265       {
29266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29267       };
29268     } catch (Dali::DaliException e) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29271       };
29272     } catch (...) {
29273       {
29274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29275       };
29276     }
29277   }
29278
29279   jresult = (void *)result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29285   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29286
29287   arg1 = (Dali::TouchPoint *)jarg1;
29288   {
29289     try {
29290       delete arg1;
29291     } catch (std::out_of_range& e) {
29292       {
29293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29294       };
29295     } catch (std::exception& e) {
29296       {
29297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29298       };
29299     } catch (Dali::DaliException e) {
29300       {
29301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29302       };
29303     } catch (...) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29306       };
29307     }
29308   }
29309
29310 }
29311
29312
29313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29314   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29315   int arg2 ;
29316
29317   arg1 = (Dali::TouchPoint *)jarg1;
29318   arg2 = (int)jarg2;
29319   if (arg1) (arg1)->deviceId = arg2;
29320 }
29321
29322
29323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29324   int jresult ;
29325   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29326   int result;
29327
29328   arg1 = (Dali::TouchPoint *)jarg1;
29329   result = (int) ((arg1)->deviceId);
29330   jresult = result;
29331   return jresult;
29332 }
29333
29334
29335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29336   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29337   Dali::TouchPoint::State arg2 ;
29338
29339   arg1 = (Dali::TouchPoint *)jarg1;
29340   arg2 = (Dali::TouchPoint::State)jarg2;
29341   if (arg1) (arg1)->state = arg2;
29342 }
29343
29344
29345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29346   int jresult ;
29347   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29348   Dali::TouchPoint::State result;
29349
29350   arg1 = (Dali::TouchPoint *)jarg1;
29351   result = (Dali::TouchPoint::State) ((arg1)->state);
29352   jresult = (int)result;
29353   return jresult;
29354 }
29355
29356
29357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29358   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29359   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29360
29361   arg1 = (Dali::TouchPoint *)jarg1;
29362   arg2 = (Dali::Actor *)jarg2;
29363   if (arg1) (arg1)->hitActor = *arg2;
29364 }
29365
29366
29367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29368   void * jresult ;
29369   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29370   Dali::Actor *result = 0 ;
29371
29372   arg1 = (Dali::TouchPoint *)jarg1;
29373   result = (Dali::Actor *)& ((arg1)->hitActor);
29374   jresult = (void *)result;
29375   return jresult;
29376 }
29377
29378
29379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29380   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29381   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29382
29383   arg1 = (Dali::TouchPoint *)jarg1;
29384   arg2 = (Dali::Vector2 *)jarg2;
29385   if (arg1) (arg1)->local = *arg2;
29386 }
29387
29388
29389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29390   void * jresult ;
29391   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29392   Dali::Vector2 *result = 0 ;
29393
29394   arg1 = (Dali::TouchPoint *)jarg1;
29395   result = (Dali::Vector2 *)& ((arg1)->local);
29396   jresult = (void *)result;
29397   return jresult;
29398 }
29399
29400
29401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29402   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29403   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29404
29405   arg1 = (Dali::TouchPoint *)jarg1;
29406   arg2 = (Dali::Vector2 *)jarg2;
29407   if (arg1) (arg1)->screen = *arg2;
29408 }
29409
29410
29411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29412   void * jresult ;
29413   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29414   Dali::Vector2 *result = 0 ;
29415
29416   arg1 = (Dali::TouchPoint *)jarg1;
29417   result = (Dali::Vector2 *)& ((arg1)->screen);
29418   jresult = (void *)result;
29419   return jresult;
29420 }
29421
29422
29423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29424   void * jresult ;
29425   Dali::TouchEvent *result = 0 ;
29426
29427   {
29428     try {
29429       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29430     } catch (std::out_of_range& e) {
29431       {
29432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29433       };
29434     } catch (std::exception& e) {
29435       {
29436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29437       };
29438     } catch (Dali::DaliException e) {
29439       {
29440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29441       };
29442     } catch (...) {
29443       {
29444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29445       };
29446     }
29447   }
29448
29449   jresult = (void *)result;
29450   return jresult;
29451 }
29452
29453
29454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29455   void * jresult ;
29456   Dali::TouchEvent *arg1 = 0 ;
29457   Dali::TouchEvent *result = 0 ;
29458
29459   arg1 = (Dali::TouchEvent *)jarg1;
29460   if (!arg1) {
29461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29462     return 0;
29463   }
29464   {
29465     try {
29466       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29467     } catch (std::out_of_range& e) {
29468       {
29469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29470       };
29471     } catch (std::exception& e) {
29472       {
29473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29474       };
29475     } catch (Dali::DaliException e) {
29476       {
29477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29478       };
29479     } catch (...) {
29480       {
29481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29482       };
29483     }
29484   }
29485
29486   jresult = (void *)result;
29487   return jresult;
29488 }
29489
29490
29491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29492   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29493
29494   arg1 = (Dali::TouchEvent *)jarg1;
29495   {
29496     try {
29497       delete arg1;
29498     } catch (std::out_of_range& e) {
29499       {
29500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29501       };
29502     } catch (std::exception& e) {
29503       {
29504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29505       };
29506     } catch (Dali::DaliException e) {
29507       {
29508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29509       };
29510     } catch (...) {
29511       {
29512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29513       };
29514     }
29515   }
29516
29517 }
29518
29519
29520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29521   void * jresult ;
29522   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29523   Dali::TouchEvent *arg2 = 0 ;
29524   Dali::TouchEvent *result = 0 ;
29525
29526   arg1 = (Dali::TouchEvent *)jarg1;
29527   arg2 = (Dali::TouchEvent *)jarg2;
29528   if (!arg2) {
29529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29530     return 0;
29531   }
29532   {
29533     try {
29534       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29535     } catch (std::out_of_range& e) {
29536       {
29537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (std::exception& e) {
29540       {
29541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29542       };
29543     } catch (Dali::DaliException e) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29546       };
29547     } catch (...) {
29548       {
29549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29550       };
29551     }
29552   }
29553
29554   jresult = (void *)result;
29555   return jresult;
29556 }
29557
29558
29559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29560   unsigned long jresult ;
29561   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29562   unsigned long result;
29563
29564   arg1 = (Dali::TouchEvent *)jarg1;
29565   {
29566     try {
29567       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29568     } catch (std::out_of_range& e) {
29569       {
29570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29571       };
29572     } catch (std::exception& e) {
29573       {
29574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29575       };
29576     } catch (Dali::DaliException e) {
29577       {
29578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29579       };
29580     } catch (...) {
29581       {
29582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29583       };
29584     }
29585   }
29586
29587   jresult = (unsigned long)result;
29588   return jresult;
29589 }
29590
29591
29592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29593   unsigned long jresult ;
29594   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29595   std::size_t result;
29596
29597   arg1 = (Dali::TouchEvent *)jarg1;
29598   {
29599     try {
29600       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29601     } catch (std::out_of_range& e) {
29602       {
29603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29604       };
29605     } catch (std::exception& e) {
29606       {
29607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29608       };
29609     } catch (Dali::DaliException e) {
29610       {
29611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29612       };
29613     } catch (...) {
29614       {
29615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29616       };
29617     }
29618   }
29619
29620   jresult = (unsigned long)result;
29621   return jresult;
29622 }
29623
29624
29625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29626   int jresult ;
29627   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29628   std::size_t arg2 ;
29629   int32_t result;
29630
29631   arg1 = (Dali::TouchEvent *)jarg1;
29632   arg2 = (std::size_t)jarg2;
29633   {
29634     try {
29635       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29636     } catch (std::out_of_range& e) {
29637       {
29638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29639       };
29640     } catch (std::exception& e) {
29641       {
29642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29643       };
29644     } catch (Dali::DaliException e) {
29645       {
29646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29647       };
29648     } catch (...) {
29649       {
29650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29651       };
29652     }
29653   }
29654
29655   jresult = result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29661   int jresult ;
29662   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29663   std::size_t arg2 ;
29664   Dali::PointState::Type result;
29665
29666   arg1 = (Dali::TouchEvent *)jarg1;
29667   arg2 = (std::size_t)jarg2;
29668   {
29669     try {
29670       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29671     } catch (std::out_of_range& e) {
29672       {
29673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29674       };
29675     } catch (std::exception& e) {
29676       {
29677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29678       };
29679     } catch (Dali::DaliException e) {
29680       {
29681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29682       };
29683     } catch (...) {
29684       {
29685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29686       };
29687     }
29688   }
29689
29690   jresult = (int)result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29696   void * jresult ;
29697   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29698   std::size_t arg2 ;
29699   Dali::Actor result;
29700
29701   arg1 = (Dali::TouchEvent *)jarg1;
29702   arg2 = (std::size_t)jarg2;
29703   {
29704     try {
29705       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29706     } catch (std::out_of_range& e) {
29707       {
29708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (std::exception& e) {
29711       {
29712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29713       };
29714     } catch (Dali::DaliException e) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29717       };
29718     } catch (...) {
29719       {
29720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29721       };
29722     }
29723   }
29724
29725   jresult = new Dali::Actor((const Dali::Actor &)result);
29726   return jresult;
29727 }
29728
29729
29730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29731   void * jresult ;
29732   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29733   std::size_t arg2 ;
29734   Dali::Vector2 *result = 0 ;
29735
29736   arg1 = (Dali::TouchEvent *)jarg1;
29737   arg2 = (std::size_t)jarg2;
29738   {
29739     try {
29740       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29741     } catch (std::out_of_range& e) {
29742       {
29743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29744       };
29745     } catch (std::exception& e) {
29746       {
29747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29748       };
29749     } catch (Dali::DaliException e) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29752       };
29753     } catch (...) {
29754       {
29755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29756       };
29757     }
29758   }
29759
29760   jresult = (void *)result;
29761   return jresult;
29762 }
29763
29764
29765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29766   void * jresult ;
29767   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29768   std::size_t arg2 ;
29769   Dali::Vector2 *result = 0 ;
29770
29771   arg1 = (Dali::TouchEvent *)jarg1;
29772   arg2 = (std::size_t)jarg2;
29773   {
29774     try {
29775       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29776     } catch (std::out_of_range& e) {
29777       {
29778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29779       };
29780     } catch (std::exception& e) {
29781       {
29782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29783       };
29784     } catch (Dali::DaliException e) {
29785       {
29786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29787       };
29788     } catch (...) {
29789       {
29790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29791       };
29792     }
29793   }
29794
29795   jresult = (void *)result;
29796   return jresult;
29797 }
29798
29799
29800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29801   float jresult ;
29802   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29803   std::size_t arg2 ;
29804   float result;
29805
29806   arg1 = (Dali::TouchEvent *)jarg1;
29807   arg2 = (std::size_t)jarg2;
29808   {
29809     try {
29810       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29811     } catch (std::out_of_range& e) {
29812       {
29813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (std::exception& e) {
29816       {
29817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29818       };
29819     } catch (Dali::DaliException e) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29822       };
29823     } catch (...) {
29824       {
29825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29826       };
29827     }
29828   }
29829
29830   jresult = result;
29831   return jresult;
29832 }
29833
29834
29835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29836   void * jresult ;
29837   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29838   std::size_t arg2 ;
29839   Dali::Vector2 *result = 0 ;
29840
29841   arg1 = (Dali::TouchEvent *)jarg1;
29842   arg2 = (std::size_t)jarg2;
29843   {
29844     try {
29845       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29846     } catch (std::out_of_range& e) {
29847       {
29848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29849       };
29850     } catch (std::exception& e) {
29851       {
29852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (Dali::DaliException e) {
29855       {
29856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29857       };
29858     } catch (...) {
29859       {
29860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29861       };
29862     }
29863   }
29864
29865   jresult = (void *)result;
29866   return jresult;
29867 }
29868
29869
29870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29871   float jresult ;
29872   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29873   std::size_t arg2 ;
29874   float result;
29875
29876   arg1 = (Dali::TouchEvent *)jarg1;
29877   arg2 = (std::size_t)jarg2;
29878   {
29879     try {
29880       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29881     } catch (std::out_of_range& e) {
29882       {
29883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29884       };
29885     } catch (std::exception& e) {
29886       {
29887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29888       };
29889     } catch (Dali::DaliException e) {
29890       {
29891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29892       };
29893     } catch (...) {
29894       {
29895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29896       };
29897     }
29898   }
29899
29900   jresult = result;
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29906   void * jresult ;
29907   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29908   std::size_t arg2 ;
29909   Dali::Degree result;
29910
29911   arg1 = (Dali::TouchEvent *)jarg1;
29912   arg2 = (std::size_t)jarg2;
29913   {
29914     try {
29915       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29916     } catch (std::out_of_range& e) {
29917       {
29918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29919       };
29920     } catch (std::exception& e) {
29921       {
29922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29923       };
29924     } catch (Dali::DaliException e) {
29925       {
29926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29927       };
29928     } catch (...) {
29929       {
29930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29931       };
29932     }
29933   }
29934
29935   jresult = new Dali::Degree((const Dali::Degree &)result);
29936   return jresult;
29937 }
29938
29939
29940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29941   int jresult ;
29942   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29943   std::size_t arg2 ;
29944   Dali::MouseButton::Type result;
29945
29946   arg1 = (Dali::TouchEvent *)jarg1;
29947   arg2 = (std::size_t)jarg2;
29948   {
29949     try {
29950       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29951     } catch (std::out_of_range& e) {
29952       {
29953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (std::exception& e) {
29956       {
29957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29958       };
29959     } catch (Dali::DaliException e) {
29960       {
29961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29962       };
29963     } catch (...) {
29964       {
29965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29966       };
29967     }
29968   }
29969
29970   jresult = static_cast< int >(result);
29971   return jresult;
29972 }
29973
29974
29975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29976   void * jresult ;
29977   Dali::GestureDetector *result = 0 ;
29978
29979   {
29980     try {
29981       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29982     } catch (std::out_of_range& e) {
29983       {
29984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29985       };
29986     } catch (std::exception& e) {
29987       {
29988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29989       };
29990     } catch (Dali::DaliException e) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29993       };
29994     } catch (...) {
29995       {
29996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29997       };
29998     }
29999   }
30000
30001   jresult = (void *)result;
30002   return jresult;
30003 }
30004
30005
30006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30007   void * jresult ;
30008   Dali::BaseHandle arg1 ;
30009   Dali::BaseHandle *argp1 ;
30010   Dali::GestureDetector result;
30011
30012   argp1 = (Dali::BaseHandle *)jarg1;
30013   if (!argp1) {
30014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30015     return 0;
30016   }
30017   arg1 = *argp1;
30018   {
30019     try {
30020       result = Dali::GestureDetector::DownCast(arg1);
30021     } catch (std::out_of_range& e) {
30022       {
30023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30024       };
30025     } catch (std::exception& e) {
30026       {
30027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30028       };
30029     } catch (Dali::DaliException e) {
30030       {
30031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30032       };
30033     } catch (...) {
30034       {
30035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30036       };
30037     }
30038   }
30039
30040   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30041   return jresult;
30042 }
30043
30044
30045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30046   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30047
30048   arg1 = (Dali::GestureDetector *)jarg1;
30049   {
30050     try {
30051       delete arg1;
30052     } catch (std::out_of_range& e) {
30053       {
30054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30055       };
30056     } catch (std::exception& e) {
30057       {
30058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30059       };
30060     } catch (Dali::DaliException e) {
30061       {
30062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30063       };
30064     } catch (...) {
30065       {
30066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30067       };
30068     }
30069   }
30070
30071 }
30072
30073
30074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30075   void * jresult ;
30076   Dali::GestureDetector *arg1 = 0 ;
30077   Dali::GestureDetector *result = 0 ;
30078
30079   arg1 = (Dali::GestureDetector *)jarg1;
30080   if (!arg1) {
30081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30082     return 0;
30083   }
30084   {
30085     try {
30086       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30087     } catch (std::out_of_range& e) {
30088       {
30089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30090       };
30091     } catch (std::exception& e) {
30092       {
30093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30094       };
30095     } catch (Dali::DaliException e) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30102       };
30103     }
30104   }
30105
30106   jresult = (void *)result;
30107   return jresult;
30108 }
30109
30110
30111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30112   void * jresult ;
30113   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30114   Dali::GestureDetector *arg2 = 0 ;
30115   Dali::GestureDetector *result = 0 ;
30116
30117   arg1 = (Dali::GestureDetector *)jarg1;
30118   arg2 = (Dali::GestureDetector *)jarg2;
30119   if (!arg2) {
30120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30121     return 0;
30122   }
30123   {
30124     try {
30125       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30126     } catch (std::out_of_range& e) {
30127       {
30128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30129       };
30130     } catch (std::exception& e) {
30131       {
30132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30133       };
30134     } catch (Dali::DaliException e) {
30135       {
30136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30137       };
30138     } catch (...) {
30139       {
30140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30141       };
30142     }
30143   }
30144
30145   jresult = (void *)result;
30146   return jresult;
30147 }
30148
30149
30150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30151   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30152   Dali::Actor arg2 ;
30153   Dali::Actor *argp2 ;
30154
30155   arg1 = (Dali::GestureDetector *)jarg1;
30156   argp2 = (Dali::Actor *)jarg2;
30157   if (!argp2) {
30158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30159     return ;
30160   }
30161   arg2 = *argp2;
30162   {
30163     try {
30164       (arg1)->Attach(arg2);
30165     } catch (std::out_of_range& e) {
30166       {
30167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30168       };
30169     } catch (std::exception& e) {
30170       {
30171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30172       };
30173     } catch (Dali::DaliException e) {
30174       {
30175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30176       };
30177     } catch (...) {
30178       {
30179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30180       };
30181     }
30182   }
30183
30184 }
30185
30186
30187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30188   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30189   Dali::Actor arg2 ;
30190   Dali::Actor *argp2 ;
30191
30192   arg1 = (Dali::GestureDetector *)jarg1;
30193   argp2 = (Dali::Actor *)jarg2;
30194   if (!argp2) {
30195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30196     return ;
30197   }
30198   arg2 = *argp2;
30199   {
30200     try {
30201       (arg1)->Detach(arg2);
30202     } catch (std::out_of_range& e) {
30203       {
30204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30205       };
30206     } catch (std::exception& e) {
30207       {
30208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30209       };
30210     } catch (Dali::DaliException e) {
30211       {
30212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30213       };
30214     } catch (...) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30217       };
30218     }
30219   }
30220
30221 }
30222
30223
30224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30225   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30226
30227   arg1 = (Dali::GestureDetector *)jarg1;
30228   {
30229     try {
30230       (arg1)->DetachAll();
30231     } catch (std::out_of_range& e) {
30232       {
30233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30234       };
30235     } catch (std::exception& e) {
30236       {
30237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30238       };
30239     } catch (Dali::DaliException e) {
30240       {
30241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30242       };
30243     } catch (...) {
30244       {
30245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30246       };
30247     }
30248   }
30249
30250 }
30251
30252
30253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30254   unsigned long jresult ;
30255   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30256   size_t result;
30257
30258   arg1 = (Dali::GestureDetector *)jarg1;
30259   {
30260     try {
30261       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30262     } catch (std::out_of_range& e) {
30263       {
30264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30265       };
30266     } catch (std::exception& e) {
30267       {
30268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30269       };
30270     } catch (Dali::DaliException e) {
30271       {
30272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30273       };
30274     } catch (...) {
30275       {
30276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30277       };
30278     }
30279   }
30280
30281   jresult = (unsigned long)result;
30282   return jresult;
30283 }
30284
30285
30286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30287   void * jresult ;
30288   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30289   size_t arg2 ;
30290   Dali::Actor result;
30291
30292   arg1 = (Dali::GestureDetector *)jarg1;
30293   arg2 = (size_t)jarg2;
30294   {
30295     try {
30296       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30297     } catch (std::out_of_range& e) {
30298       {
30299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (std::exception& e) {
30302       {
30303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30304       };
30305     } catch (Dali::DaliException e) {
30306       {
30307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30308       };
30309     } catch (...) {
30310       {
30311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30312       };
30313     }
30314   }
30315
30316   jresult = new Dali::Actor((const Dali::Actor &)result);
30317   return jresult;
30318 }
30319
30320
30321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30322   void * jresult ;
30323   Dali::Gesture *arg1 = 0 ;
30324   Dali::Gesture *result = 0 ;
30325
30326   arg1 = (Dali::Gesture *)jarg1;
30327   if (!arg1) {
30328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30329     return 0;
30330   }
30331   {
30332     try {
30333       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30334     } catch (std::out_of_range& e) {
30335       {
30336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30337       };
30338     } catch (std::exception& e) {
30339       {
30340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30341       };
30342     } catch (Dali::DaliException e) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30345       };
30346     } catch (...) {
30347       {
30348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30349       };
30350     }
30351   }
30352
30353   jresult = (void *)result;
30354   return jresult;
30355 }
30356
30357
30358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30359   void * jresult ;
30360   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30361   Dali::Gesture *arg2 = 0 ;
30362   Dali::Gesture *result = 0 ;
30363
30364   arg1 = (Dali::Gesture *)jarg1;
30365   arg2 = (Dali::Gesture *)jarg2;
30366   if (!arg2) {
30367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30368     return 0;
30369   }
30370   {
30371     try {
30372       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
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 (Dali::DaliException e) {
30382       {
30383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30384       };
30385     } catch (...) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30388       };
30389     }
30390   }
30391
30392   jresult = (void *)result;
30393   return jresult;
30394 }
30395
30396
30397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30398   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30399
30400   arg1 = (Dali::Gesture *)jarg1;
30401   {
30402     try {
30403       delete arg1;
30404     } catch (std::out_of_range& e) {
30405       {
30406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30407       };
30408     } catch (std::exception& e) {
30409       {
30410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30411       };
30412     } catch (Dali::DaliException e) {
30413       {
30414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30415       };
30416     } catch (...) {
30417       {
30418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30419       };
30420     }
30421   }
30422
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30427   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30428   Dali::Gesture::Type arg2 ;
30429
30430   arg1 = (Dali::Gesture *)jarg1;
30431   arg2 = (Dali::Gesture::Type)jarg2;
30432   if (arg1) (arg1)->type = arg2;
30433 }
30434
30435
30436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30437   int jresult ;
30438   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30439   Dali::Gesture::Type result;
30440
30441   arg1 = (Dali::Gesture *)jarg1;
30442   result = (Dali::Gesture::Type) ((arg1)->type);
30443   jresult = (int)result;
30444   return jresult;
30445 }
30446
30447
30448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30449   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30450   Dali::Gesture::State arg2 ;
30451
30452   arg1 = (Dali::Gesture *)jarg1;
30453   arg2 = (Dali::Gesture::State)jarg2;
30454   if (arg1) (arg1)->state = arg2;
30455 }
30456
30457
30458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30459   int jresult ;
30460   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30461   Dali::Gesture::State result;
30462
30463   arg1 = (Dali::Gesture *)jarg1;
30464   result = (Dali::Gesture::State) ((arg1)->state);
30465   jresult = (int)result;
30466   return jresult;
30467 }
30468
30469
30470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30471   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30472   unsigned int arg2 ;
30473
30474   arg1 = (Dali::Gesture *)jarg1;
30475   arg2 = (unsigned int)jarg2;
30476   if (arg1) (arg1)->time = arg2;
30477 }
30478
30479
30480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30481   unsigned int jresult ;
30482   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30483   unsigned int result;
30484
30485   arg1 = (Dali::Gesture *)jarg1;
30486   result = (unsigned int) ((arg1)->time);
30487   jresult = result;
30488   return jresult;
30489 }
30490
30491
30492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30493   void * jresult ;
30494   Dali::HoverEvent *result = 0 ;
30495
30496   {
30497     try {
30498       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30499     } catch (std::out_of_range& e) {
30500       {
30501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30502       };
30503     } catch (std::exception& e) {
30504       {
30505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30506       };
30507     } catch (Dali::DaliException e) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30510       };
30511     } catch (...) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30514       };
30515     }
30516   }
30517
30518   jresult = (void *)result;
30519   return jresult;
30520 }
30521
30522
30523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30524   void * jresult ;
30525   Dali::HoverEvent *arg1 = 0 ;
30526   Dali::HoverEvent *result = 0 ;
30527
30528   arg1 = (Dali::HoverEvent *)jarg1;
30529   if (!arg1) {
30530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30531     return 0;
30532   }
30533   {
30534     try {
30535       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30536     } catch (std::out_of_range& e) {
30537       {
30538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30539       };
30540     } catch (std::exception& e) {
30541       {
30542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30543       };
30544     } catch (Dali::DaliException e) {
30545       {
30546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30547       };
30548     } catch (...) {
30549       {
30550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30551       };
30552     }
30553   }
30554
30555   jresult = (void *)result;
30556   return jresult;
30557 }
30558
30559
30560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30561   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30562
30563   arg1 = (Dali::HoverEvent *)jarg1;
30564   {
30565     try {
30566       delete arg1;
30567     } catch (std::out_of_range& e) {
30568       {
30569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30570       };
30571     } catch (std::exception& e) {
30572       {
30573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30574       };
30575     } catch (Dali::DaliException e) {
30576       {
30577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30578       };
30579     } catch (...) {
30580       {
30581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30582       };
30583     }
30584   }
30585
30586 }
30587
30588
30589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30590   void * jresult ;
30591   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30592   Dali::HoverEvent *arg2 = 0 ;
30593   Dali::HoverEvent *result = 0 ;
30594
30595   arg1 = (Dali::HoverEvent *)jarg1;
30596   arg2 = (Dali::HoverEvent *)jarg2;
30597   if (!arg2) {
30598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30599     return 0;
30600   }
30601   {
30602     try {
30603       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30604     } catch (std::out_of_range& e) {
30605       {
30606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30607       };
30608     } catch (std::exception& e) {
30609       {
30610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30611       };
30612     } catch (Dali::DaliException e) {
30613       {
30614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30615       };
30616     } catch (...) {
30617       {
30618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30619       };
30620     }
30621   }
30622
30623   jresult = (void *)result;
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30629   unsigned long jresult ;
30630   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30631   unsigned long result;
30632
30633   arg1 = (Dali::HoverEvent *)jarg1;
30634   {
30635     try {
30636       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (Dali::DaliException e) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30648       };
30649     } catch (...) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30652       };
30653     }
30654   }
30655
30656   jresult = (unsigned long)result;
30657   return jresult;
30658 }
30659
30660
30661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30662   unsigned long jresult ;
30663   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30664   std::size_t result;
30665
30666   arg1 = (Dali::HoverEvent *)jarg1;
30667   {
30668     try {
30669       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30670     } catch (std::out_of_range& e) {
30671       {
30672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30673       };
30674     } catch (std::exception& e) {
30675       {
30676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30677       };
30678     } catch (Dali::DaliException e) {
30679       {
30680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30681       };
30682     } catch (...) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30685       };
30686     }
30687   }
30688
30689   jresult = (unsigned long)result;
30690   return jresult;
30691 }
30692
30693
30694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30695   int jresult ;
30696   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30697   std::size_t arg2 ;
30698   int32_t result;
30699
30700   arg1 = (Dali::HoverEvent *)jarg1;
30701   arg2 = (std::size_t)jarg2;
30702   {
30703     try {
30704       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30705     } catch (std::out_of_range& e) {
30706       {
30707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30708       };
30709     } catch (std::exception& e) {
30710       {
30711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30712       };
30713     } catch (Dali::DaliException e) {
30714       {
30715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30716       };
30717     } catch (...) {
30718       {
30719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30720       };
30721     }
30722   }
30723
30724   jresult = result;
30725   return jresult;
30726 }
30727
30728
30729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30730   int jresult ;
30731   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30732   std::size_t arg2 ;
30733   Dali::PointState::Type result;
30734
30735   arg1 = (Dali::HoverEvent *)jarg1;
30736   arg2 = (std::size_t)jarg2;
30737   {
30738     try {
30739       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30740     } catch (std::out_of_range& e) {
30741       {
30742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30743       };
30744     } catch (std::exception& e) {
30745       {
30746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30747       };
30748     } catch (Dali::DaliException e) {
30749       {
30750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30751       };
30752     } catch (...) {
30753       {
30754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30755       };
30756     }
30757   }
30758
30759   jresult = (int)result;
30760   return jresult;
30761 }
30762
30763
30764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30765   void * jresult ;
30766   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30767   std::size_t arg2 ;
30768   Dali::Actor result;
30769
30770   arg1 = (Dali::HoverEvent *)jarg1;
30771   arg2 = (std::size_t)jarg2;
30772   {
30773     try {
30774       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30775     } catch (std::out_of_range& e) {
30776       {
30777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30778       };
30779     } catch (std::exception& e) {
30780       {
30781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30782       };
30783     } catch (Dali::DaliException e) {
30784       {
30785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30786       };
30787     } catch (...) {
30788       {
30789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30790       };
30791     }
30792   }
30793
30794   jresult = new Dali::Actor((const Dali::Actor &)result);
30795   return jresult;
30796 }
30797
30798
30799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30800   void * jresult ;
30801   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30802   std::size_t arg2 ;
30803   Dali::Vector2 *result = 0 ;
30804
30805   arg1 = (Dali::HoverEvent *)jarg1;
30806   arg2 = (std::size_t)jarg2;
30807   {
30808     try {
30809       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30810     } catch (std::out_of_range& e) {
30811       {
30812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30813       };
30814     } catch (std::exception& e) {
30815       {
30816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30817       };
30818     } catch (Dali::DaliException e) {
30819       {
30820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30821       };
30822     } catch (...) {
30823       {
30824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30825       };
30826     }
30827   }
30828
30829   jresult = (void *)result;
30830   return jresult;
30831 }
30832
30833
30834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30835   void * jresult ;
30836   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30837   std::size_t arg2 ;
30838   Dali::Vector2 *result = 0 ;
30839
30840   arg1 = (Dali::HoverEvent *)jarg1;
30841   arg2 = (std::size_t)jarg2;
30842   {
30843     try {
30844       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30845     } catch (std::out_of_range& e) {
30846       {
30847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30848       };
30849     } catch (std::exception& e) {
30850       {
30851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30852       };
30853     } catch (Dali::DaliException e) {
30854       {
30855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30856       };
30857     } catch (...) {
30858       {
30859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30860       };
30861     }
30862   }
30863
30864   jresult = (void *)result;
30865   return jresult;
30866 }
30867
30868
30869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30870   void * jresult ;
30871   Dali::KeyEvent *result = 0 ;
30872
30873   {
30874     try {
30875       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30876     } catch (std::out_of_range& e) {
30877       {
30878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30879       };
30880     } catch (std::exception& e) {
30881       {
30882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30883       };
30884     } catch (Dali::DaliException e) {
30885       {
30886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30887       };
30888     } catch (...) {
30889       {
30890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30891       };
30892     }
30893   }
30894
30895   jresult = (void *)result;
30896   return jresult;
30897 }
30898
30899
30900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
30901   void * jresult ;
30902   Dali::KeyEvent *arg1 = 0 ;
30903   Dali::KeyEvent *result = 0 ;
30904
30905   arg1 = (Dali::KeyEvent *)jarg1;
30906   if (!arg1) {
30907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30908     return 0;
30909   }
30910   {
30911     try {
30912       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30913     } catch (std::out_of_range& e) {
30914       {
30915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (std::exception& e) {
30918       {
30919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (Dali::DaliException e) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30924       };
30925     } catch (...) {
30926       {
30927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30928       };
30929     }
30930   }
30931
30932   jresult = (void *)result;
30933   return jresult;
30934 }
30935
30936
30937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30938   void * jresult ;
30939   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30940   Dali::KeyEvent *arg2 = 0 ;
30941   Dali::KeyEvent *result = 0 ;
30942
30943   arg1 = (Dali::KeyEvent *)jarg1;
30944   arg2 = (Dali::KeyEvent *)jarg2;
30945   if (!arg2) {
30946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30947     return 0;
30948   }
30949   {
30950     try {
30951       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30952     } catch (std::out_of_range& e) {
30953       {
30954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30955       };
30956     } catch (std::exception& e) {
30957       {
30958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30959       };
30960     } catch (Dali::DaliException e) {
30961       {
30962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30963       };
30964     } catch (...) {
30965       {
30966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30967       };
30968     }
30969   }
30970
30971   jresult = (void *)result;
30972   return jresult;
30973 }
30974
30975
30976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30977   void * jresult ;
30978   std::string *arg1 = 0 ;
30979   std::string *arg2 = 0 ;
30980   int arg3 ;
30981   int arg4 ;
30982   unsigned long arg5 ;
30983   Dali::KeyEvent::State *arg6 = 0 ;
30984   Dali::KeyEvent::State temp6 ;
30985   Dali::KeyEvent result;
30986
30987   if (!jarg1) {
30988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30989     return 0;
30990   }
30991   std::string arg1_str(jarg1);
30992   arg1 = &arg1_str;
30993   if (!jarg2) {
30994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30995     return 0;
30996   }
30997   std::string arg2_str(jarg2);
30998   arg2 = &arg2_str;
30999   arg3 = (int)jarg3;
31000   arg4 = (int)jarg4;
31001   arg5 = (unsigned long)jarg5;
31002   temp6 = (Dali::KeyEvent::State)jarg6;
31003   arg6 = &temp6;
31004   {
31005     try {
31006       result = DevelKeyEvent::New((std::string const &)*arg1, "", (std::string const &)*arg2, arg3, arg4, arg5, (Dali::KeyEvent::State const &)*arg6, "", "", Device::Class::NONE, Device::Subclass::NONE);
31007     } catch (std::out_of_range& e) {
31008       {
31009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31010       };
31011     } catch (std::exception& e) {
31012       {
31013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31014       };
31015     } catch (Dali::DaliException e) {
31016       {
31017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31018       };
31019     } catch (...) {
31020       {
31021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31022       };
31023     }
31024   }
31025
31026   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
31027
31028   //argout typemap for const std::string&
31029
31030
31031   //argout typemap for const std::string&
31032
31033   return jresult;
31034 }
31035
31036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31037   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31038
31039   arg1 = (Dali::KeyEvent *)jarg1;
31040   {
31041     try {
31042       delete arg1;
31043     } catch (std::out_of_range& e) {
31044       {
31045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31046       };
31047     } catch (std::exception& e) {
31048       {
31049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31050       };
31051     } catch (Dali::DaliException e) {
31052       {
31053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31054       };
31055     } catch (...) {
31056       {
31057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31058       };
31059     }
31060   }
31061
31062 }
31063
31064
31065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31066   unsigned int jresult ;
31067   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31068   bool result;
31069
31070   arg1 = (Dali::KeyEvent *)jarg1;
31071   {
31072     try {
31073       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31074     } catch (std::out_of_range& e) {
31075       {
31076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31077       };
31078     } catch (std::exception& e) {
31079       {
31080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31081       };
31082     } catch (Dali::DaliException e) {
31083       {
31084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31085       };
31086     } catch (...) {
31087       {
31088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31089       };
31090     }
31091   }
31092
31093   jresult = result;
31094   return jresult;
31095 }
31096
31097
31098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31099   unsigned int jresult ;
31100   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31101   bool result;
31102
31103   arg1 = (Dali::KeyEvent *)jarg1;
31104   {
31105     try {
31106       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31107     } catch (std::out_of_range& e) {
31108       {
31109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31110       };
31111     } catch (std::exception& e) {
31112       {
31113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (Dali::DaliException e) {
31116       {
31117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125
31126   jresult = result;
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31132   unsigned int jresult ;
31133   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31134   bool result;
31135
31136   arg1 = (Dali::KeyEvent *)jarg1;
31137   {
31138     try {
31139       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31140     } catch (std::out_of_range& e) {
31141       {
31142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31143       };
31144     } catch (std::exception& e) {
31145       {
31146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31147       };
31148     } catch (Dali::DaliException e) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31151       };
31152     } catch (...) {
31153       {
31154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31155       };
31156     }
31157   }
31158
31159   jresult = result;
31160   return jresult;
31161 }
31162
31163
31164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31165   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31166   std::string *arg2 = 0 ;
31167
31168   Dali::KeyEvent arg1 = *argp1;
31169   if (!jarg2) {
31170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31171     return ;
31172   }
31173   std::string arg2_str(jarg2);
31174   arg2 = &arg2_str;
31175
31176   {
31177     try {
31178       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
31179     } catch (std::out_of_range& e) {
31180       {
31181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31182       };
31183     } catch (std::exception& e) {
31184       {
31185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31186       };
31187     } catch (Dali::DaliException e) {
31188       {
31189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31190       };
31191     } catch (...) {
31192       {
31193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31194       };
31195     }
31196   }
31197 }
31198
31199
31200 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31201   char * jresult ;
31202
31203   if( jarg1 == NULL )
31204   {
31205     jresult = SWIG_csharp_string_callback( "" );
31206   }
31207   else
31208   {
31209     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31210     std::string *result = 0;
31211
31212     arg1 = ( Dali::KeyEvent * )jarg1;
31213     {
31214       try {
31215         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
31216         result = (std::string *) &str;
31217       } catch (std::out_of_range& e) {
31218         {
31219           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31220         };
31221       } catch (std::exception& e) {
31222         {
31223           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31224         };
31225       } catch (Dali::DaliException e) {
31226         {
31227           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31228         };
31229       } catch (...) {
31230         {
31231           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31232         };
31233       }
31234     }
31235
31236     jresult = SWIG_csharp_string_callback(result->c_str());
31237   }
31238
31239   return jresult;
31240 }
31241
31242
31243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31244   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31245   std::string *arg2 = 0 ;
31246
31247   Dali::KeyEvent arg1 = *argp1;
31248   if (!jarg2) {
31249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31250     return ;
31251   }
31252   std::string arg2_str(jarg2);
31253   arg2 = &arg2_str;
31254
31255   {
31256     try {
31257       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
31258     } catch (std::out_of_range& e) {
31259       {
31260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31261       };
31262     } catch (std::exception& e) {
31263       {
31264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31265       };
31266     } catch (Dali::DaliException e) {
31267       {
31268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31269       };
31270     } catch (...) {
31271       {
31272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31273       };
31274     }
31275   }
31276 }
31277
31278
31279 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31280   char * jresult ;
31281
31282   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31283   std::string *result = 0;
31284
31285   arg1 = ( Dali::KeyEvent * )jarg1;
31286   {
31287     try {
31288       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
31289       result = (std::string *) &str;
31290     } catch (std::out_of_range& e) {
31291       {
31292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31293       };
31294     } catch (std::exception& e) {
31295       {
31296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31297       };
31298     } catch (Dali::DaliException e) {
31299       {
31300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31301       };
31302     } catch (...) {
31303       {
31304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31305       };
31306     }
31307
31308     jresult = SWIG_csharp_string_callback(result->c_str());
31309   }
31310
31311   return jresult;
31312 }
31313
31314
31315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31316   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31317   int arg2 ;
31318
31319   Dali::KeyEvent arg1 = *argp1;
31320   arg2 = (int)jarg2;
31321   {
31322     try {
31323       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
31324     } catch (std::out_of_range& e) {
31325       {
31326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31327       };
31328     } catch (std::exception& e) {
31329       {
31330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31331       };
31332     } catch (Dali::DaliException e) {
31333       {
31334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31335       };
31336     } catch (...) {
31337       {
31338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31339       };
31340     }
31341   }
31342 }
31343
31344
31345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31346   int jresult ;
31347   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31348   int result;
31349
31350   arg1 = (Dali::KeyEvent *)jarg1;
31351   {
31352     try {
31353       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
31354     } catch (std::out_of_range& e) {
31355       {
31356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31357       };
31358     } catch (std::exception& e) {
31359       {
31360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31361       };
31362     } catch (Dali::DaliException e) {
31363       {
31364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31365       };
31366     } catch (...) {
31367       {
31368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31369       };
31370     }
31371   }
31372
31373   jresult = result;
31374   return jresult;
31375 }
31376
31377
31378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31379   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31380   int arg2 ;
31381
31382   Dali::KeyEvent arg1 = *argp1;
31383   arg2 = (int)jarg2;
31384   {
31385     try {
31386       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31394       };
31395     } catch (Dali::DaliException e) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31398       };
31399     } catch (...) {
31400       {
31401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31402       };
31403     }
31404   }
31405 }
31406
31407
31408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31409   int jresult ;
31410   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31411   int result;
31412
31413   arg1 = (Dali::KeyEvent *)jarg1;
31414   {
31415     try {
31416       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
31417     } catch (std::out_of_range& e) {
31418       {
31419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31420       };
31421     } catch (std::exception& e) {
31422       {
31423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31424       };
31425     } catch (Dali::DaliException e) {
31426       {
31427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31428       };
31429     } catch (...) {
31430       {
31431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31432       };
31433     }
31434   }
31435
31436   jresult = result;
31437   return jresult;
31438 }
31439
31440
31441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31442   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31443   unsigned long arg2 ;
31444
31445   Dali::KeyEvent arg1 = *argp1;
31446   arg2 = (int)jarg2;
31447   {
31448     try {
31449       Dali::DevelKeyEvent::SetTime(arg1, arg2);
31450     } catch (std::out_of_range& e) {
31451       {
31452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31453       };
31454     } catch (std::exception& e) {
31455       {
31456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31457       };
31458     } catch (Dali::DaliException e) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31461       };
31462     } catch (...) {
31463       {
31464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31465       };
31466     }
31467   }
31468 }
31469
31470
31471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31472   unsigned long jresult ;
31473   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31474   unsigned long result;
31475
31476   arg1 = (Dali::KeyEvent *)jarg1;
31477   {
31478     try {
31479       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
31480     } catch (std::out_of_range& e) {
31481       {
31482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31483       };
31484     } catch (std::exception& e) {
31485       {
31486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31487       };
31488     } catch (Dali::DaliException e) {
31489       {
31490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31491       };
31492     } catch (...) {
31493       {
31494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31495       };
31496     }
31497   }
31498
31499   jresult = result;
31500   return jresult;
31501 }
31502
31503
31504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31505   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
31506   Dali::KeyEvent::State arg2;
31507
31508   Dali::KeyEvent arg1 = *argp1;
31509   arg2 = (Dali::KeyEvent::State)jarg2;
31510   {
31511     try {
31512       Dali::DevelKeyEvent::SetState(arg1, arg2);
31513     } catch (std::out_of_range& e) {
31514       {
31515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31516       };
31517     } catch (std::exception& e) {
31518       {
31519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31520       };
31521     } catch (Dali::DaliException e) {
31522       {
31523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31524       };
31525     } catch (...) {
31526       {
31527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31528       };
31529     }
31530   }
31531 }
31532
31533
31534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31535   int jresult ;
31536   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31537   Dali::KeyEvent::State result;
31538
31539   arg1 = (Dali::KeyEvent *)jarg1;
31540   {
31541     try {
31542       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
31543     } catch (std::out_of_range& e) {
31544       {
31545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31546       };
31547     } catch (std::exception& e) {
31548       {
31549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31550       };
31551     } catch (Dali::DaliException e) {
31552       {
31553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31554       };
31555     } catch (...) {
31556       {
31557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31558       };
31559     }
31560   }
31561
31562   jresult = (int)result;
31563   return jresult;
31564
31565 }
31566
31567 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31568   char * jresult ;
31569
31570   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31571   std::string *result = 0;
31572
31573   arg1 = ( Dali::KeyEvent * )jarg1;
31574   {
31575     try {
31576       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
31577       result = (std::string *) &str;
31578     } catch (std::out_of_range& e) {
31579       {
31580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31581       };
31582     } catch (std::exception& e) {
31583       {
31584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31585       };
31586     } catch (Dali::DaliException e) {
31587       {
31588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31589       };
31590     } catch (...) {
31591       {
31592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31593       };
31594     }
31595
31596   }
31597
31598   jresult = SWIG_csharp_string_callback(result->c_str());
31599   return jresult;
31600 }
31601
31602
31603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31604   void * jresult ;
31605   Dali::LongPressGestureDetector *result = 0 ;
31606
31607   {
31608     try {
31609       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31610     } catch (std::out_of_range& e) {
31611       {
31612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31613       };
31614     } catch (std::exception& e) {
31615       {
31616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31617       };
31618     } catch (Dali::DaliException e) {
31619       {
31620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31621       };
31622     } catch (...) {
31623       {
31624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31625       };
31626     }
31627   }
31628
31629   jresult = (void *)result;
31630   return jresult;
31631 }
31632
31633
31634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31635   void * jresult ;
31636   Dali::LongPressGestureDetector result;
31637
31638   {
31639     try {
31640       result = Dali::LongPressGestureDetector::New();
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (Dali::DaliException e) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31652       };
31653     } catch (...) {
31654       {
31655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31656       };
31657     }
31658   }
31659
31660   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31661   return jresult;
31662 }
31663
31664
31665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31666   void * jresult ;
31667   unsigned int arg1 ;
31668   Dali::LongPressGestureDetector result;
31669
31670   arg1 = (unsigned int)jarg1;
31671   {
31672     try {
31673       result = Dali::LongPressGestureDetector::New(arg1);
31674     } catch (std::out_of_range& e) {
31675       {
31676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31677       };
31678     } catch (std::exception& e) {
31679       {
31680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31681       };
31682     } catch (Dali::DaliException e) {
31683       {
31684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31685       };
31686     } catch (...) {
31687       {
31688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31689       };
31690     }
31691   }
31692
31693   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31694   return jresult;
31695 }
31696
31697
31698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31699   void * jresult ;
31700   unsigned int arg1 ;
31701   unsigned int arg2 ;
31702   Dali::LongPressGestureDetector result;
31703
31704   arg1 = (unsigned int)jarg1;
31705   arg2 = (unsigned int)jarg2;
31706   {
31707     try {
31708       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31709     } catch (std::out_of_range& e) {
31710       {
31711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (std::exception& e) {
31714       {
31715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31716       };
31717     } catch (Dali::DaliException e) {
31718       {
31719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31720       };
31721     } catch (...) {
31722       {
31723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31724       };
31725     }
31726   }
31727
31728   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31729   return jresult;
31730 }
31731
31732
31733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31734   void * jresult ;
31735   Dali::BaseHandle arg1 ;
31736   Dali::BaseHandle *argp1 ;
31737   Dali::LongPressGestureDetector result;
31738
31739   argp1 = (Dali::BaseHandle *)jarg1;
31740   if (!argp1) {
31741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31742     return 0;
31743   }
31744   arg1 = *argp1;
31745   {
31746     try {
31747       result = Dali::LongPressGestureDetector::DownCast(arg1);
31748     } catch (std::out_of_range& e) {
31749       {
31750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31751       };
31752     } catch (std::exception& e) {
31753       {
31754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31755       };
31756     } catch (Dali::DaliException e) {
31757       {
31758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31759       };
31760     } catch (...) {
31761       {
31762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31763       };
31764     }
31765   }
31766
31767   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31768   return jresult;
31769 }
31770
31771
31772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31773   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31774
31775   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31776   {
31777     try {
31778       delete arg1;
31779     } catch (std::out_of_range& e) {
31780       {
31781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31782       };
31783     } catch (std::exception& e) {
31784       {
31785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31786       };
31787     } catch (Dali::DaliException e) {
31788       {
31789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31790       };
31791     } catch (...) {
31792       {
31793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31794       };
31795     }
31796   }
31797
31798 }
31799
31800
31801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31802   void * jresult ;
31803   Dali::LongPressGestureDetector *arg1 = 0 ;
31804   Dali::LongPressGestureDetector *result = 0 ;
31805
31806   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31807   if (!arg1) {
31808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31809     return 0;
31810   }
31811   {
31812     try {
31813       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31814     } catch (std::out_of_range& e) {
31815       {
31816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31817       };
31818     } catch (std::exception& e) {
31819       {
31820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31821       };
31822     } catch (Dali::DaliException e) {
31823       {
31824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31825       };
31826     } catch (...) {
31827       {
31828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31829       };
31830     }
31831   }
31832
31833   jresult = (void *)result;
31834   return jresult;
31835 }
31836
31837
31838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31839   void * jresult ;
31840   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31841   Dali::LongPressGestureDetector *arg2 = 0 ;
31842   Dali::LongPressGestureDetector *result = 0 ;
31843
31844   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31845   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31846   if (!arg2) {
31847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31848     return 0;
31849   }
31850   {
31851     try {
31852       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31853     } catch (std::out_of_range& e) {
31854       {
31855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31856       };
31857     } catch (std::exception& e) {
31858       {
31859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31860       };
31861     } catch (Dali::DaliException e) {
31862       {
31863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31864       };
31865     } catch (...) {
31866       {
31867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31868       };
31869     }
31870   }
31871
31872   jresult = (void *)result;
31873   return jresult;
31874 }
31875
31876
31877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31878   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31879   unsigned int arg2 ;
31880
31881   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31882   arg2 = (unsigned int)jarg2;
31883   {
31884     try {
31885       (arg1)->SetTouchesRequired(arg2);
31886     } catch (std::out_of_range& e) {
31887       {
31888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31889       };
31890     } catch (std::exception& e) {
31891       {
31892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31893       };
31894     } catch (Dali::DaliException e) {
31895       {
31896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31897       };
31898     } catch (...) {
31899       {
31900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31901       };
31902     }
31903   }
31904
31905 }
31906
31907
31908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31909   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31910   unsigned int arg2 ;
31911   unsigned int arg3 ;
31912
31913   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31914   arg2 = (unsigned int)jarg2;
31915   arg3 = (unsigned int)jarg3;
31916   {
31917     try {
31918       (arg1)->SetTouchesRequired(arg2,arg3);
31919     } catch (std::out_of_range& e) {
31920       {
31921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31922       };
31923     } catch (std::exception& e) {
31924       {
31925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31926       };
31927     } catch (Dali::DaliException e) {
31928       {
31929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31930       };
31931     } catch (...) {
31932       {
31933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31934       };
31935     }
31936   }
31937
31938 }
31939
31940
31941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31942   unsigned int jresult ;
31943   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31944   unsigned int result;
31945
31946   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31947   {
31948     try {
31949       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31950     } catch (std::out_of_range& e) {
31951       {
31952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31953       };
31954     } catch (std::exception& e) {
31955       {
31956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31957       };
31958     } catch (Dali::DaliException e) {
31959       {
31960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31961       };
31962     } catch (...) {
31963       {
31964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31965       };
31966     }
31967   }
31968
31969   jresult = result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31975   unsigned int jresult ;
31976   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31977   unsigned int result;
31978
31979   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31980   {
31981     try {
31982       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31983     } catch (std::out_of_range& e) {
31984       {
31985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31986       };
31987     } catch (std::exception& e) {
31988       {
31989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31990       };
31991     } catch (Dali::DaliException e) {
31992       {
31993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31994       };
31995     } catch (...) {
31996       {
31997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31998       };
31999     }
32000   }
32001
32002   jresult = result;
32003   return jresult;
32004 }
32005
32006
32007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32008   void * jresult ;
32009   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32010   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32011
32012   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32013   {
32014     try {
32015       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32016     } catch (std::out_of_range& e) {
32017       {
32018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (std::exception& e) {
32021       {
32022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32023       };
32024     } catch (Dali::DaliException e) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32027       };
32028     } catch (...) {
32029       {
32030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32031       };
32032     }
32033   }
32034
32035   jresult = (void *)result;
32036   return jresult;
32037 }
32038
32039
32040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32041   void * jresult ;
32042   Dali::Gesture::State arg1 ;
32043   Dali::LongPressGesture *result = 0 ;
32044
32045   arg1 = (Dali::Gesture::State)jarg1;
32046   {
32047     try {
32048       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32049     } catch (std::out_of_range& e) {
32050       {
32051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32052       };
32053     } catch (std::exception& e) {
32054       {
32055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32056       };
32057     } catch (Dali::DaliException e) {
32058       {
32059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32060       };
32061     } catch (...) {
32062       {
32063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32064       };
32065     }
32066   }
32067
32068   jresult = (void *)result;
32069   return jresult;
32070 }
32071
32072
32073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32074   void * jresult ;
32075   Dali::LongPressGesture *arg1 = 0 ;
32076   Dali::LongPressGesture *result = 0 ;
32077
32078   arg1 = (Dali::LongPressGesture *)jarg1;
32079   if (!arg1) {
32080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32081     return 0;
32082   }
32083   {
32084     try {
32085       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32086     } catch (std::out_of_range& e) {
32087       {
32088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32089       };
32090     } catch (std::exception& e) {
32091       {
32092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32093       };
32094     } catch (Dali::DaliException e) {
32095       {
32096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32097       };
32098     } catch (...) {
32099       {
32100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32101       };
32102     }
32103   }
32104
32105   jresult = (void *)result;
32106   return jresult;
32107 }
32108
32109
32110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32111   void * jresult ;
32112   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32113   Dali::LongPressGesture *arg2 = 0 ;
32114   Dali::LongPressGesture *result = 0 ;
32115
32116   arg1 = (Dali::LongPressGesture *)jarg1;
32117   arg2 = (Dali::LongPressGesture *)jarg2;
32118   if (!arg2) {
32119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32120     return 0;
32121   }
32122   {
32123     try {
32124       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32125     } catch (std::out_of_range& e) {
32126       {
32127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32128       };
32129     } catch (std::exception& e) {
32130       {
32131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32132       };
32133     } catch (Dali::DaliException e) {
32134       {
32135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32136       };
32137     } catch (...) {
32138       {
32139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32140       };
32141     }
32142   }
32143
32144   jresult = (void *)result;
32145   return jresult;
32146 }
32147
32148
32149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32150   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32151
32152   arg1 = (Dali::LongPressGesture *)jarg1;
32153   {
32154     try {
32155       delete arg1;
32156     } catch (std::out_of_range& e) {
32157       {
32158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32159       };
32160     } catch (std::exception& e) {
32161       {
32162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32163       };
32164     } catch (Dali::DaliException e) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32167       };
32168     } catch (...) {
32169       {
32170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32171       };
32172     }
32173   }
32174
32175 }
32176
32177
32178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32179   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32180   unsigned int arg2 ;
32181
32182   arg1 = (Dali::LongPressGesture *)jarg1;
32183   arg2 = (unsigned int)jarg2;
32184   if (arg1) (arg1)->numberOfTouches = arg2;
32185 }
32186
32187
32188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32189   unsigned int jresult ;
32190   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32191   unsigned int result;
32192
32193   arg1 = (Dali::LongPressGesture *)jarg1;
32194   result = (unsigned int) ((arg1)->numberOfTouches);
32195   jresult = result;
32196   return jresult;
32197 }
32198
32199
32200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32201   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32202   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32203
32204   arg1 = (Dali::LongPressGesture *)jarg1;
32205   arg2 = (Dali::Vector2 *)jarg2;
32206   if (arg1) (arg1)->screenPoint = *arg2;
32207 }
32208
32209
32210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32211   void * jresult ;
32212   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32213   Dali::Vector2 *result = 0 ;
32214
32215   arg1 = (Dali::LongPressGesture *)jarg1;
32216   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32217   jresult = (void *)result;
32218   return jresult;
32219 }
32220
32221
32222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32223   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32224   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32225
32226   arg1 = (Dali::LongPressGesture *)jarg1;
32227   arg2 = (Dali::Vector2 *)jarg2;
32228   if (arg1) (arg1)->localPoint = *arg2;
32229 }
32230
32231
32232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32233   void * jresult ;
32234   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32235   Dali::Vector2 *result = 0 ;
32236
32237   arg1 = (Dali::LongPressGesture *)jarg1;
32238   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32239   jresult = (void *)result;
32240   return jresult;
32241 }
32242
32243
32244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32245   void * jresult ;
32246   Dali::WheelEvent *result = 0 ;
32247
32248   {
32249     try {
32250       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32251     } catch (std::out_of_range& e) {
32252       {
32253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (std::exception& e) {
32256       {
32257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32258       };
32259     } catch (Dali::DaliException e) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32262       };
32263     } catch (...) {
32264       {
32265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32266       };
32267     }
32268   }
32269
32270   jresult = (void *)result;
32271   return jresult;
32272 }
32273
32274
32275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
32276   void * jresult ;
32277   Dali::WheelEvent *arg1 = 0 ;
32278   Dali::WheelEvent *result = 0 ;
32279
32280   arg1 = (Dali::WheelEvent *)jarg1;
32281   if (!arg1) {
32282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32283     return 0;
32284   }
32285   {
32286     try {
32287       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
32288     } catch (std::out_of_range& e) {
32289       {
32290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32291       };
32292     } catch (std::exception& e) {
32293       {
32294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32295       };
32296     } catch (Dali::DaliException e) {
32297       {
32298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32299       };
32300     } catch (...) {
32301       {
32302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32303       };
32304     }
32305   }
32306
32307   jresult = (void *)result;
32308   return jresult;
32309 }
32310
32311
32312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
32313   void * jresult ;
32314   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32315   Dali::WheelEvent *arg2 = 0 ;
32316   Dali::WheelEvent *result = 0 ;
32317
32318   arg1 = (Dali::WheelEvent *)jarg1;
32319   arg2 = (Dali::WheelEvent *)jarg2;
32320   if (!arg2) {
32321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32322     return 0;
32323   }
32324   {
32325     try {
32326       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
32327     } catch (std::out_of_range& e) {
32328       {
32329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32330       };
32331     } catch (std::exception& e) {
32332       {
32333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32334       };
32335     } catch (Dali::DaliException e) {
32336       {
32337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32338       };
32339     } catch (...) {
32340       {
32341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32342       };
32343     }
32344   }
32345
32346   jresult = (void *)result;
32347   return jresult;
32348 }
32349
32350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32351   void * jresult ;
32352   Dali::WheelEvent::Type arg1 ;
32353   int arg2 ;
32354   unsigned int arg3 ;
32355   Dali::Vector2 arg4 ;
32356   int arg5 ;
32357   unsigned int arg6 ;
32358   Dali::Vector2 *argp4 ;
32359   Dali::WheelEvent result;
32360
32361   arg1 = (Dali::WheelEvent::Type)jarg1;
32362   arg2 = (int)jarg2;
32363   arg3 = (unsigned int)jarg3;
32364   argp4 = (Dali::Vector2 *)jarg4;
32365   if (!argp4) {
32366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32367     return 0;
32368   }
32369   arg4 = *argp4;
32370   arg5 = (int)jarg5;
32371   arg6 = (unsigned int)jarg6;
32372   {
32373     try {
32374       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
32375     } catch (std::out_of_range& e) {
32376       {
32377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (std::exception& e) {
32380       {
32381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32382       };
32383     } catch (Dali::DaliException e) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32386       };
32387     } catch (...) {
32388       {
32389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32390       };
32391     }
32392   }
32393
32394   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
32395   return jresult;
32396 }
32397
32398
32399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32401
32402   arg1 = (Dali::WheelEvent *)jarg1;
32403   {
32404     try {
32405       delete arg1;
32406     } catch (std::out_of_range& e) {
32407       {
32408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32409       };
32410     } catch (std::exception& e) {
32411       {
32412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32413       };
32414     } catch (Dali::DaliException e) {
32415       {
32416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32417       };
32418     } catch (...) {
32419       {
32420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32421       };
32422     }
32423   }
32424
32425 }
32426
32427
32428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32429   unsigned int jresult ;
32430   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32431   bool result;
32432
32433   arg1 = (Dali::WheelEvent *)jarg1;
32434   {
32435     try {
32436       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32437     } catch (std::out_of_range& e) {
32438       {
32439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32440       };
32441     } catch (std::exception& e) {
32442       {
32443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32444       };
32445     } catch (Dali::DaliException e) {
32446       {
32447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32448       };
32449     } catch (...) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32452       };
32453     }
32454   }
32455
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32462   unsigned int jresult ;
32463   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32464   bool result;
32465
32466   arg1 = (Dali::WheelEvent *)jarg1;
32467   {
32468     try {
32469       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32470     } catch (std::out_of_range& e) {
32471       {
32472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32473       };
32474     } catch (std::exception& e) {
32475       {
32476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32477       };
32478     } catch (Dali::DaliException e) {
32479       {
32480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32481       };
32482     } catch (...) {
32483       {
32484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32485       };
32486     }
32487   }
32488
32489   jresult = result;
32490   return jresult;
32491 }
32492
32493
32494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32495   unsigned int jresult ;
32496   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32497   bool result;
32498
32499   arg1 = (Dali::WheelEvent *)jarg1;
32500   {
32501     try {
32502       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32503     } catch (std::out_of_range& e) {
32504       {
32505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (std::exception& e) {
32508       {
32509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (Dali::DaliException e) {
32512       {
32513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32514       };
32515     } catch (...) {
32516       {
32517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32518       };
32519     }
32520   }
32521
32522   jresult = result;
32523   return jresult;
32524 }
32525
32526
32527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32528   int jresult ;
32529   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32530   Dali::WheelEvent::Type result;
32531
32532   arg1 = (Dali::WheelEvent *)jarg1;
32533   {
32534     try {
32535       result = ((Dali::WheelEvent const *)arg1)->GetType();
32536     } catch (std::out_of_range& e) {
32537       {
32538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32539       };
32540     } catch (std::exception& e) {
32541       {
32542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32543       };
32544     } catch (Dali::DaliException e) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32547       };
32548     } catch (...) {
32549       {
32550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32551       };
32552     }
32553   }
32554
32555   jresult = (int)result;
32556   return jresult;
32557 }
32558
32559
32560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32561   int jresult ;
32562   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32563   int result;
32564
32565   arg1 = (Dali::WheelEvent *)jarg1;
32566   {
32567     try {
32568       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
32569     } catch (std::out_of_range& e) {
32570       {
32571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32572       };
32573     } catch (std::exception& e) {
32574       {
32575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (Dali::DaliException e) {
32578       {
32579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32580       };
32581     } catch (...) {
32582       {
32583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32584       };
32585     }
32586   }
32587
32588   jresult = result;
32589   return jresult;
32590 }
32591
32592
32593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32594   unsigned int jresult ;
32595   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32596   unsigned int result;
32597
32598   arg1 = (Dali::WheelEvent *)jarg1;
32599   {
32600     try {
32601       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
32602     } catch (std::out_of_range& e) {
32603       {
32604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32605       };
32606     } catch (std::exception& e) {
32607       {
32608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32609       };
32610     } catch (Dali::DaliException e) {
32611       {
32612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32613       };
32614     } catch (...) {
32615       {
32616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32617       };
32618     }
32619   }
32620
32621   jresult = result;
32622   return jresult;
32623 }
32624
32625
32626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32627   void * jresult ;
32628   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32629   Dali::Vector2 *result = 0 ;
32630
32631   arg1 = (Dali::WheelEvent *)jarg1;
32632   {
32633     try {
32634       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
32635     } catch (std::out_of_range& e) {
32636       {
32637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32638       };
32639     } catch (std::exception& e) {
32640       {
32641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32642       };
32643     } catch (Dali::DaliException e) {
32644       {
32645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32646       };
32647     } catch (...) {
32648       {
32649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32650       };
32651     }
32652   }
32653
32654   jresult = (void *)result;
32655   return jresult;
32656 }
32657
32658
32659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
32660   int jresult ;
32661   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32662   int result;
32663
32664   arg1 = (Dali::WheelEvent *)jarg1;
32665   {
32666     try {
32667       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
32668     } catch (std::out_of_range& e) {
32669       {
32670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32671       };
32672     } catch (std::exception& e) {
32673       {
32674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32675       };
32676     } catch (Dali::DaliException e) {
32677       {
32678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32679       };
32680     } catch (...) {
32681       {
32682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32683       };
32684     }
32685   }
32686
32687   jresult = result;
32688   return jresult;
32689 }
32690
32691
32692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32693   unsigned int jresult ;
32694   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32695   unsigned int result;
32696
32697   arg1 = (Dali::WheelEvent *)jarg1;
32698   {
32699     try {
32700       result = ((Dali::WheelEvent const *)arg1)->GetTime();
32701     } catch (std::out_of_range& e) {
32702       {
32703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32704       };
32705     } catch (std::exception& e) {
32706       {
32707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32708       };
32709     } catch (Dali::DaliException e) {
32710       {
32711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32712       };
32713     } catch (...) {
32714       {
32715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32716       };
32717     }
32718   }
32719
32720   jresult = result;
32721   return jresult;
32722 }
32723
32724 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32725   char * jresult ;
32726   Dali::KeyEvent *arg1 = 0 ;
32727   std::string result;
32728
32729   arg1 = (Dali::KeyEvent *)jarg1;
32730   if (!arg1) {
32731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32732     return 0;
32733   }
32734   {
32735     try {
32736       result = arg1->GetDeviceName();
32737     } catch (std::out_of_range& e) {
32738       {
32739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32740       };
32741     } catch (std::exception& e) {
32742       {
32743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32744       };
32745     } catch (Dali::DaliException e) {
32746       {
32747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32748       };
32749     } catch (...) {
32750       {
32751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32752       };
32753     }
32754   }
32755
32756   jresult = SWIG_csharp_string_callback((&result)->c_str());
32757   return jresult;
32758 }
32759
32760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32761   int jresult ;
32762   Dali::KeyEvent *arg1 = 0 ;
32763   Dali::Device::Class::Type result;
32764
32765   arg1 = (Dali::KeyEvent *)jarg1;
32766   if (!arg1) {
32767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32768     return 0;
32769   }
32770   {
32771     try {
32772       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32773     } catch (std::out_of_range& e) {
32774       {
32775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32776       };
32777     } catch (std::exception& e) {
32778       {
32779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32780       };
32781     } catch (Dali::DaliException e) {
32782       {
32783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32784       };
32785     } catch (...) {
32786       {
32787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32788       };
32789     }
32790   }
32791
32792   jresult = (int)result;
32793   return jresult;
32794 }
32795
32796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32797   int jresult ;
32798   Dali::KeyEvent *arg1 = 0 ;
32799   Dali::Device::Subclass::Type result;
32800
32801   arg1 = (Dali::KeyEvent *)jarg1;
32802   if (!arg1) {
32803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32804     return 0;
32805   }
32806   {
32807     try {
32808       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32809     } catch (std::out_of_range& e) {
32810       {
32811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32812       };
32813     } catch (std::exception& e) {
32814       {
32815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32816       };
32817     } catch (Dali::DaliException e) {
32818       {
32819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32820       };
32821     } catch (...) {
32822       {
32823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32824       };
32825     }
32826   }
32827
32828   jresult = (int)result;
32829   return jresult;
32830 }
32831
32832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32833   Dali::Actor arg1 ;
32834   Dali::Actor *argp1 ;
32835
32836   argp1 = (Dali::Actor *)jarg1;
32837   if (!argp1) {
32838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32839     return ;
32840   }
32841   arg1 = *argp1;
32842   {
32843     try {
32844       arg1.Raise();
32845     } catch (std::out_of_range& e) {
32846       {
32847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32848       };
32849     } catch (std::exception& e) {
32850       {
32851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32852       };
32853     } catch (Dali::DaliException e) {
32854       {
32855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32856       };
32857     } catch (...) {
32858       {
32859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32860       };
32861     }
32862   }
32863
32864 }
32865
32866
32867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32868   Dali::Actor arg1 ;
32869   Dali::Actor *argp1 ;
32870
32871   argp1 = (Dali::Actor *)jarg1;
32872   if (!argp1) {
32873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32874     return ;
32875   }
32876   arg1 = *argp1;
32877   {
32878     try {
32879       arg1.Lower();
32880     } catch (std::out_of_range& e) {
32881       {
32882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32883       };
32884     } catch (std::exception& e) {
32885       {
32886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32887       };
32888     } catch (Dali::DaliException e) {
32889       {
32890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32891       };
32892     } catch (...) {
32893       {
32894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32895       };
32896     }
32897   }
32898
32899 }
32900
32901
32902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32903   Dali::Actor arg1 ;
32904   Dali::Actor *argp1 ;
32905
32906   argp1 = (Dali::Actor *)jarg1;
32907   if (!argp1) {
32908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32909     return ;
32910   }
32911   arg1 = *argp1;
32912   {
32913     try {
32914       arg1.RaiseToTop();
32915     } catch (std::out_of_range& e) {
32916       {
32917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32918       };
32919     } catch (std::exception& e) {
32920       {
32921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32922       };
32923     } catch (Dali::DaliException e) {
32924       {
32925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32926       };
32927     } catch (...) {
32928       {
32929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32930       };
32931     }
32932   }
32933
32934 }
32935
32936
32937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32938   Dali::Actor arg1 ;
32939   Dali::Actor *argp1 ;
32940
32941   argp1 = (Dali::Actor *)jarg1;
32942   if (!argp1) {
32943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32944     return ;
32945   }
32946   arg1 = *argp1;
32947   {
32948     try {
32949       arg1.LowerToBottom();
32950     } catch (std::out_of_range& e) {
32951       {
32952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32953       };
32954     } catch (std::exception& e) {
32955       {
32956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32957       };
32958     } catch (Dali::DaliException e) {
32959       {
32960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32961       };
32962     } catch (...) {
32963       {
32964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32965       };
32966     }
32967   }
32968
32969 }
32970
32971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32972   Dali::Actor arg1 ;
32973   Dali::Actor arg2 ;
32974   Dali::Actor *argp1 ;
32975   Dali::Actor *argp2 ;
32976
32977   argp1 = (Dali::Actor *)jarg1;
32978   if (!argp1) {
32979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32980     return ;
32981   }
32982   arg1 = *argp1;
32983   argp2 = (Dali::Actor *)jarg2;
32984   if (!argp2) {
32985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32986     return ;
32987   }
32988   arg2 = *argp2;
32989   {
32990     try {
32991       arg1.RaiseAbove(arg2);
32992     } catch (std::out_of_range& e) {
32993       {
32994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32995       };
32996     } catch (std::exception& e) {
32997       {
32998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32999       };
33000     } catch (Dali::DaliException e) {
33001       {
33002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33003       };
33004     } catch (...) {
33005       {
33006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33007       };
33008     }
33009   }
33010
33011 }
33012
33013
33014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
33015   Dali::Actor arg1 ;
33016   Dali::Actor arg2 ;
33017   Dali::Actor *argp1 ;
33018   Dali::Actor *argp2 ;
33019
33020   argp1 = (Dali::Actor *)jarg1;
33021   if (!argp1) {
33022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33023     return ;
33024   }
33025   arg1 = *argp1;
33026   argp2 = (Dali::Actor *)jarg2;
33027   if (!argp2) {
33028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33029     return ;
33030   }
33031   arg2 = *argp2;
33032   {
33033     try {
33034       arg1.LowerBelow(arg2);
33035     } catch (std::out_of_range& e) {
33036       {
33037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33038       };
33039     } catch (std::exception& e) {
33040       {
33041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33042       };
33043     } catch (Dali::DaliException e) {
33044       {
33045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33046       };
33047     } catch (...) {
33048       {
33049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33050       };
33051     }
33052   }
33053
33054 }
33055
33056
33057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
33058   void * jresult ;
33059   Dali::Actor arg1 ;
33060   Dali::Actor *argp1 ;
33061   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
33062
33063   argp1 = (Dali::Actor *)jarg1;
33064   if (!argp1) {
33065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33066     return 0;
33067   }
33068   arg1 = *argp1;
33069   {
33070     try {
33071       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
33072     } catch (std::out_of_range& e) {
33073       {
33074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33075       };
33076     } catch (std::exception& e) {
33077       {
33078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33079       };
33080     } catch (Dali::DaliException e) {
33081       {
33082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33083       };
33084     } catch (...) {
33085       {
33086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33087       };
33088     }
33089   }
33090
33091   jresult = (void *)result;
33092   return jresult;
33093 }
33094
33095
33096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
33097   void * jresult ;
33098   Dali::Actor *arg1 ;
33099   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
33100
33101   arg1 = (Dali::Actor *)jarg1;
33102   {
33103     try {
33104       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
33105     } catch (std::out_of_range& e) {
33106       {
33107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33108       };
33109     } catch (std::exception& e) {
33110       {
33111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33112       };
33113     } catch (Dali::DaliException e) {
33114       {
33115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33116       };
33117     } catch (...) {
33118       {
33119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33120       };
33121     }
33122   }
33123
33124   jresult = (void *)result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33130   int jresult ;
33131   int result;
33132
33133   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33134   jresult = (int)result;
33135   return jresult;
33136 }
33137
33138
33139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33140   int jresult ;
33141   int result;
33142
33143   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33144   jresult = (int)result;
33145   return jresult;
33146 }
33147
33148
33149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33150   int jresult ;
33151   int result;
33152
33153   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33154   jresult = (int)result;
33155   return jresult;
33156 }
33157
33158
33159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33160   int jresult ;
33161   int result;
33162
33163   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33164   jresult = (int)result;
33165   return jresult;
33166 }
33167
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33170   int jresult ;
33171   int result;
33172
33173   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33174   jresult = (int)result;
33175   return jresult;
33176 }
33177
33178
33179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33180   int jresult ;
33181   int result;
33182
33183   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33184   jresult = (int)result;
33185   return jresult;
33186 }
33187
33188
33189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33190   int jresult ;
33191   int result;
33192
33193   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33194   jresult = (int)result;
33195   return jresult;
33196 }
33197
33198
33199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33200   int jresult ;
33201   int result;
33202
33203   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33204   jresult = (int)result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33210   int jresult ;
33211   int result;
33212
33213   result = (int)Dali::Actor::Property::SIZE;
33214   jresult = (int)result;
33215   return jresult;
33216 }
33217
33218
33219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33220   int jresult ;
33221   int result;
33222
33223   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33224   jresult = (int)result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33230   int jresult ;
33231   int result;
33232
33233   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33234   jresult = (int)result;
33235   return jresult;
33236 }
33237
33238
33239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33240   int jresult ;
33241   int result;
33242
33243   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33244   jresult = (int)result;
33245   return jresult;
33246 }
33247
33248
33249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33250   int jresult ;
33251   int result;
33252
33253   result = (int)Dali::Actor::Property::POSITION;
33254   jresult = (int)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33260   int jresult ;
33261   int result;
33262
33263   result = (int)Dali::Actor::Property::POSITION_X;
33264   jresult = (int)result;
33265   return jresult;
33266 }
33267
33268
33269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33270   int jresult ;
33271   int result;
33272
33273   result = (int)Dali::Actor::Property::POSITION_Y;
33274   jresult = (int)result;
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33280   int jresult ;
33281   int result;
33282
33283   result = (int)Dali::Actor::Property::POSITION_Z;
33284   jresult = (int)result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33290   int jresult ;
33291   int result;
33292
33293   result = (int)Dali::Actor::Property::WORLD_POSITION;
33294   jresult = (int)result;
33295   return jresult;
33296 }
33297
33298
33299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33300   int jresult ;
33301   int result;
33302
33303   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33304   jresult = (int)result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33310   int jresult ;
33311   int result;
33312
33313   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33314   jresult = (int)result;
33315   return jresult;
33316 }
33317
33318
33319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33320   int jresult ;
33321   int result;
33322
33323   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33324   jresult = (int)result;
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33330   int jresult ;
33331   int result;
33332
33333   result = (int)Dali::Actor::Property::ORIENTATION;
33334   jresult = (int)result;
33335   return jresult;
33336 }
33337
33338
33339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33340   int jresult ;
33341   int result;
33342
33343   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33344   jresult = (int)result;
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33350   int jresult ;
33351   int result;
33352
33353   result = (int)Dali::Actor::Property::SCALE;
33354   jresult = (int)result;
33355   return jresult;
33356 }
33357
33358
33359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33360   int jresult ;
33361   int result;
33362
33363   result = (int)Dali::Actor::Property::SCALE_X;
33364   jresult = (int)result;
33365   return jresult;
33366 }
33367
33368
33369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33370   int jresult ;
33371   int result;
33372
33373   result = (int)Dali::Actor::Property::SCALE_Y;
33374   jresult = (int)result;
33375   return jresult;
33376 }
33377
33378
33379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33380   int jresult ;
33381   int result;
33382
33383   result = (int)Dali::Actor::Property::SCALE_Z;
33384   jresult = (int)result;
33385   return jresult;
33386 }
33387
33388
33389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33390   int jresult ;
33391   int result;
33392
33393   result = (int)Dali::Actor::Property::WORLD_SCALE;
33394   jresult = (int)result;
33395   return jresult;
33396 }
33397
33398
33399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33400   int jresult ;
33401   int result;
33402
33403   result = (int)Dali::Actor::Property::VISIBLE;
33404   jresult = (int)result;
33405   return jresult;
33406 }
33407
33408
33409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33410   int jresult ;
33411   int result;
33412
33413   result = (int)Dali::Actor::Property::COLOR;
33414   jresult = (int)result;
33415   return jresult;
33416 }
33417
33418
33419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33420   int jresult ;
33421   int result;
33422
33423   result = (int)Dali::Actor::Property::COLOR_RED;
33424   jresult = (int)result;
33425   return jresult;
33426 }
33427
33428
33429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33430   int jresult ;
33431   int result;
33432
33433   result = (int)Dali::Actor::Property::COLOR_GREEN;
33434   jresult = (int)result;
33435   return jresult;
33436 }
33437
33438
33439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33440   int jresult ;
33441   int result;
33442
33443   result = (int)Dali::Actor::Property::COLOR_BLUE;
33444   jresult = (int)result;
33445   return jresult;
33446 }
33447
33448
33449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33450   int jresult ;
33451   int result;
33452
33453   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33454   jresult = (int)result;
33455   return jresult;
33456 }
33457
33458
33459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33460   int jresult ;
33461   int result;
33462
33463   result = (int)Dali::Actor::Property::WORLD_COLOR;
33464   jresult = (int)result;
33465   return jresult;
33466 }
33467
33468
33469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33470   int jresult ;
33471   int result;
33472
33473   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33474   jresult = (int)result;
33475   return jresult;
33476 }
33477
33478
33479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33480   int jresult ;
33481   int result;
33482
33483   result = (int)Dali::Actor::Property::NAME;
33484   jresult = (int)result;
33485   return jresult;
33486 }
33487
33488
33489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33490   int jresult ;
33491   int result;
33492
33493   result = (int)Dali::Actor::Property::SENSITIVE;
33494   jresult = (int)result;
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33500   int jresult ;
33501   int result;
33502
33503   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33504   jresult = (int)result;
33505   return jresult;
33506 }
33507
33508
33509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33510   int jresult ;
33511   int result;
33512
33513   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33514   jresult = (int)result;
33515   return jresult;
33516 }
33517
33518
33519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33520   int jresult ;
33521   int result;
33522
33523   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33524   jresult = (int)result;
33525   return jresult;
33526 }
33527
33528
33529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33530   int jresult ;
33531   int result;
33532
33533   result = (int)Dali::Actor::Property::COLOR_MODE;
33534   jresult = (int)result;
33535   return jresult;
33536 }
33537
33538
33539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33540   int jresult ;
33541   int result;
33542
33543   result = (int)Dali::Actor::Property::DRAW_MODE;
33544   jresult = (int)result;
33545   return jresult;
33546 }
33547
33548
33549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33550   int jresult ;
33551   int result;
33552
33553   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33554   jresult = (int)result;
33555   return jresult;
33556 }
33557
33558
33559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33560   int jresult ;
33561   int result;
33562
33563   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33564   jresult = (int)result;
33565   return jresult;
33566 }
33567
33568
33569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33570   int jresult ;
33571   int result;
33572
33573   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33574   jresult = (int)result;
33575   return jresult;
33576 }
33577
33578
33579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33580   int jresult ;
33581   int result;
33582
33583   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33584   jresult = (int)result;
33585   return jresult;
33586 }
33587
33588
33589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33590   int jresult ;
33591   int result;
33592
33593   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33594   jresult = (int)result;
33595   return jresult;
33596 }
33597
33598
33599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33600   int jresult ;
33601   int result;
33602
33603   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33604   jresult = (int)result;
33605   return jresult;
33606 }
33607
33608
33609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33610   int jresult ;
33611   int result;
33612
33613   result = (int)Dali::Actor::Property::PADDING;
33614   jresult = (int)result;
33615   return jresult;
33616 }
33617
33618
33619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33620   int jresult ;
33621   int result;
33622
33623   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33624   jresult = (int)result;
33625   return jresult;
33626 }
33627
33628
33629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33630   int jresult ;
33631   int result;
33632
33633   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33634   jresult = (int)result;
33635   return jresult;
33636 }
33637
33638
33639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33640   int jresult ;
33641   int result;
33642
33643   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33644   jresult = (int)result;
33645   return jresult;
33646 }
33647
33648
33649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33650   int jresult ;
33651   int result;
33652
33653   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33654   jresult = (int)result;
33655   return jresult;
33656 }
33657
33658 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33659
33660   return Dali::Actor::Property::OPACITY;
33661 }
33662
33663 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33664
33665   return Dali::Actor::Property::SCREEN_POSITION;
33666 }
33667
33668 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33669
33670   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33671 }
33672
33673 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33674   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33675 }
33676
33677 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33678   return Dali::Actor::Property::LAYOUT_DIRECTION;
33679 }
33680
33681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33682   void * jresult ;
33683   Dali::Actor::Property *result = 0 ;
33684
33685   {
33686     try {
33687       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33688     } catch (std::out_of_range& e) {
33689       {
33690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33691       };
33692     } catch (std::exception& e) {
33693       {
33694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33695       };
33696     } catch (Dali::DaliException e) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33699       };
33700     } catch (...) {
33701       {
33702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33703       };
33704     }
33705   }
33706
33707   jresult = (void *)result;
33708   return jresult;
33709 }
33710
33711
33712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33713   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33714
33715   arg1 = (Dali::Actor::Property *)jarg1;
33716   {
33717     try {
33718       delete arg1;
33719     } catch (std::out_of_range& e) {
33720       {
33721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33722       };
33723     } catch (std::exception& e) {
33724       {
33725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33726       };
33727     } catch (Dali::DaliException e) {
33728       {
33729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33730       };
33731     } catch (...) {
33732       {
33733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33734       };
33735     }
33736   }
33737
33738 }
33739
33740
33741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33742   void * jresult ;
33743   Dali::Actor *result = 0 ;
33744
33745   {
33746     try {
33747       result = (Dali::Actor *)new Dali::Actor();
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (Dali::DaliException e) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33759       };
33760     } catch (...) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33763       };
33764     }
33765   }
33766
33767   jresult = (void *)result;
33768   return jresult;
33769 }
33770
33771
33772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33773   void * jresult ;
33774   Dali::Actor result;
33775
33776   {
33777     try {
33778       result = Dali::Actor::New();
33779     } catch (std::out_of_range& e) {
33780       {
33781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33782       };
33783     } catch (std::exception& e) {
33784       {
33785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33786       };
33787     } catch (Dali::DaliException e) {
33788       {
33789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33790       };
33791     } catch (...) {
33792       {
33793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33794       };
33795     }
33796   }
33797
33798   jresult = new Dali::Actor((const Dali::Actor &)result);
33799   return jresult;
33800 }
33801
33802
33803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33804   void * jresult ;
33805   Dali::BaseHandle arg1 ;
33806   Dali::BaseHandle *argp1 ;
33807   Dali::Actor result;
33808
33809   argp1 = (Dali::BaseHandle *)jarg1;
33810   if (!argp1) {
33811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33812     return 0;
33813   }
33814   arg1 = *argp1;
33815   {
33816     try {
33817       result = Dali::Actor::DownCast(arg1);
33818     } catch (std::out_of_range& e) {
33819       {
33820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (std::exception& e) {
33823       {
33824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (Dali::DaliException e) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33833       };
33834     }
33835   }
33836
33837   jresult = new Dali::Actor((const Dali::Actor &)result);
33838   return jresult;
33839 }
33840
33841
33842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33844
33845   arg1 = (Dali::Actor *)jarg1;
33846   {
33847     try {
33848       delete arg1;
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 (Dali::DaliException e) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33860       };
33861     } catch (...) {
33862       {
33863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33864       };
33865     }
33866   }
33867
33868 }
33869
33870
33871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33872   void * jresult ;
33873   Dali::Actor *arg1 = 0 ;
33874   Dali::Actor *result = 0 ;
33875
33876   arg1 = (Dali::Actor *)jarg1;
33877   if (!arg1) {
33878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33879     return 0;
33880   }
33881   {
33882     try {
33883       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33884     } catch (std::out_of_range& e) {
33885       {
33886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (std::exception& e) {
33889       {
33890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (Dali::DaliException e) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33895       };
33896     } catch (...) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33899       };
33900     }
33901   }
33902
33903   jresult = (void *)result;
33904   return jresult;
33905 }
33906
33907
33908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33909   void * jresult ;
33910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33911   Dali::Actor *arg2 = 0 ;
33912   Dali::Actor *result = 0 ;
33913
33914   arg1 = (Dali::Actor *)jarg1;
33915   arg2 = (Dali::Actor *)jarg2;
33916   if (!arg2) {
33917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33918     return 0;
33919   }
33920   {
33921     try {
33922       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33923     } catch (std::out_of_range& e) {
33924       {
33925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33926       };
33927     } catch (std::exception& e) {
33928       {
33929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33930       };
33931     } catch (Dali::DaliException e) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33934       };
33935     } catch (...) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33938       };
33939     }
33940   }
33941
33942   jresult = (void *)result;
33943   return jresult;
33944 }
33945
33946
33947 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33948   char * jresult ;
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950   std::string *result = 0 ;
33951   std::string name = "";
33952
33953   arg1 = (Dali::Actor *)jarg1;
33954   {
33955     try {
33956       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33957       result = (std::string *) &name;
33958       jresult = SWIG_csharp_string_callback(result->c_str());
33959     } catch (std::out_of_range& e) {
33960       {
33961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33962       };
33963     } catch (std::exception& e) {
33964       {
33965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33966       };
33967     } catch (Dali::DaliException e) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33970       };
33971     } catch (...) {
33972       {
33973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33974       };
33975     }
33976   }
33977   return jresult;
33978 }
33979
33980
33981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33983   std::string *arg2 = 0 ;
33984
33985   arg1 = (Dali::Actor *)jarg1;
33986   if (!jarg2) {
33987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33988     return ;
33989   }
33990   std::string arg2_str(jarg2);
33991   arg2 = &arg2_str;
33992   {
33993     try {
33994       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33995     } catch (std::out_of_range& e) {
33996       {
33997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33998       };
33999     } catch (std::exception& e) {
34000       {
34001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34002       };
34003     } catch (Dali::DaliException e) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34010       };
34011     }
34012   }
34013
34014
34015   //argout typemap for const std::string&
34016
34017 }
34018
34019
34020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
34021   unsigned int jresult ;
34022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34023   unsigned int result;
34024
34025   arg1 = (Dali::Actor *)jarg1;
34026
34027   if(!arg1) {
34028     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
34029     return -1;
34030   }
34031
34032   {
34033     try {
34034       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
34035     } catch (std::out_of_range& e) {
34036       {
34037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34038       };
34039     } catch (std::exception& e) {
34040       {
34041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34042       };
34043     } catch (Dali::DaliException e) {
34044       {
34045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34046       };
34047     } catch (...) {
34048       {
34049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34050       };
34051     }
34052   }
34053
34054   jresult = result;
34055   return jresult;
34056 }
34057
34058
34059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
34060   unsigned int jresult ;
34061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34062   bool result;
34063
34064   arg1 = (Dali::Actor *)jarg1;
34065   {
34066     try {
34067       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
34068     } catch (std::out_of_range& e) {
34069       {
34070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34071       };
34072     } catch (std::exception& e) {
34073       {
34074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34075       };
34076     } catch (Dali::DaliException e) {
34077       {
34078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34079       };
34080     } catch (...) {
34081       {
34082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34083       };
34084     }
34085   }
34086
34087   jresult = result;
34088   return jresult;
34089 }
34090
34091
34092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
34093   unsigned int jresult ;
34094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34095   bool result;
34096
34097   arg1 = (Dali::Actor *)jarg1;
34098   {
34099     try {
34100       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
34101     } catch (std::out_of_range& e) {
34102       {
34103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (std::exception& e) {
34106       {
34107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34108       };
34109     } catch (Dali::DaliException e) {
34110       {
34111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34112       };
34113     } catch (...) {
34114       {
34115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34116       };
34117     }
34118   }
34119
34120   jresult = result;
34121   return jresult;
34122 }
34123
34124
34125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
34126   unsigned int jresult ;
34127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34128   bool result;
34129
34130   arg1 = (Dali::Actor *)jarg1;
34131   {
34132     try {
34133       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
34134     } catch (std::out_of_range& e) {
34135       {
34136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34137       };
34138     } catch (std::exception& e) {
34139       {
34140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34141       };
34142     } catch (Dali::DaliException e) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34145       };
34146     } catch (...) {
34147       {
34148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34149       };
34150     }
34151   }
34152
34153   jresult = result;
34154   return jresult;
34155 }
34156
34157
34158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34159   void * jresult ;
34160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34161   Dali::Layer result;
34162
34163   arg1 = (Dali::Actor *)jarg1;
34164   {
34165     try {
34166       result = (arg1)->GetLayer();
34167     } catch (std::out_of_range& e) {
34168       {
34169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34170       };
34171     } catch (std::exception& e) {
34172       {
34173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34174       };
34175     } catch (Dali::DaliException e) {
34176       {
34177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34182       };
34183     }
34184   }
34185
34186   jresult = new Dali::Layer((const Dali::Layer &)result);
34187   return jresult;
34188 }
34189
34190
34191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34192   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34193   Dali::Actor arg2 ;
34194   Dali::Actor *argp2 ;
34195
34196   arg1 = (Dali::Actor *)jarg1;
34197   argp2 = (Dali::Actor *)jarg2;
34198   if (!argp2) {
34199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34200     return ;
34201   }
34202   arg2 = *argp2;
34203   {
34204     try {
34205       (arg1)->Add(arg2);
34206     } catch (std::out_of_range& e) {
34207       {
34208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34209       };
34210     } catch (std::exception& e) {
34211       {
34212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34213       };
34214     } catch (Dali::DaliException e) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34217       };
34218     } catch (...) {
34219       {
34220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34221       };
34222     }
34223   }
34224
34225 }
34226
34227
34228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34230   Dali::Actor arg2 ;
34231   Dali::Actor *argp2 ;
34232
34233   arg1 = (Dali::Actor *)jarg1;
34234   argp2 = (Dali::Actor *)jarg2;
34235   if (!argp2) {
34236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34237     return ;
34238   }
34239   arg2 = *argp2;
34240   {
34241     try {
34242       (arg1)->Remove(arg2);
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34250       };
34251     } catch (Dali::DaliException e) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34254       };
34255     } catch (...) {
34256       {
34257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34258       };
34259     }
34260   }
34261
34262 }
34263
34264
34265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34267
34268   arg1 = (Dali::Actor *)jarg1;
34269   {
34270     try {
34271       (arg1)->Unparent();
34272     } catch (std::out_of_range& e) {
34273       {
34274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (std::exception& e) {
34277       {
34278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34279       };
34280     } catch (Dali::DaliException e) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34283       };
34284     } catch (...) {
34285       {
34286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34287       };
34288     }
34289   }
34290
34291 }
34292
34293
34294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34295   unsigned int jresult ;
34296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34297   unsigned int result;
34298
34299   arg1 = (Dali::Actor *)jarg1;
34300   {
34301     try {
34302       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34310       };
34311     } catch (Dali::DaliException e) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34318       };
34319     }
34320   }
34321
34322   jresult = result;
34323   return jresult;
34324 }
34325
34326
34327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34328   void * jresult ;
34329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34330   unsigned int arg2 ;
34331   Dali::Actor result;
34332
34333   arg1 = (Dali::Actor *)jarg1;
34334   arg2 = (unsigned int)jarg2;
34335   {
34336     try {
34337       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34353       };
34354     }
34355   }
34356
34357   jresult = new Dali::Actor((const Dali::Actor &)result);
34358   return jresult;
34359 }
34360
34361
34362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34363   void * jresult ;
34364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34365   std::string *arg2 = 0 ;
34366   Dali::Actor result;
34367
34368   arg1 = (Dali::Actor *)jarg1;
34369   if (!jarg2) {
34370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34371     return 0;
34372   }
34373   std::string arg2_str(jarg2);
34374   arg2 = &arg2_str;
34375   {
34376     try {
34377       result = (arg1)->FindChildByName((std::string const &)*arg2);
34378     } catch (std::out_of_range& e) {
34379       {
34380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34381       };
34382     } catch (std::exception& e) {
34383       {
34384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34385       };
34386     } catch (Dali::DaliException e) {
34387       {
34388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34389       };
34390     } catch (...) {
34391       {
34392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34393       };
34394     }
34395   }
34396
34397   jresult = new Dali::Actor((const Dali::Actor &)result);
34398
34399   //argout typemap for const std::string&
34400
34401   return jresult;
34402 }
34403
34404
34405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34406   void * jresult ;
34407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34408   unsigned int arg2 ;
34409   Dali::Actor result;
34410
34411   arg1 = (Dali::Actor *)jarg1;
34412   arg2 = (unsigned int)jarg2;
34413   {
34414     try {
34415       result = (arg1)->FindChildById(arg2);
34416     } catch (std::out_of_range& e) {
34417       {
34418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34419       };
34420     } catch (std::exception& e) {
34421       {
34422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34423       };
34424     } catch (Dali::DaliException e) {
34425       {
34426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34427       };
34428     } catch (...) {
34429       {
34430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34431       };
34432     }
34433   }
34434
34435   jresult = new Dali::Actor((const Dali::Actor &)result);
34436   return jresult;
34437 }
34438
34439
34440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34441   void * jresult ;
34442   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34443   Dali::Actor result;
34444
34445   arg1 = (Dali::Actor *)jarg1;
34446   {
34447     try {
34448       result = ((Dali::Actor const *)arg1)->GetParent();
34449     } catch (std::out_of_range& e) {
34450       {
34451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34452       };
34453     } catch (std::exception& e) {
34454       {
34455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34456       };
34457     } catch (Dali::DaliException e) {
34458       {
34459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34460       };
34461     } catch (...) {
34462       {
34463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34464       };
34465     }
34466   }
34467
34468   jresult = new Dali::Actor((const Dali::Actor &)result);
34469   return jresult;
34470 }
34471
34472
34473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34475   Dali::Vector3 *arg2 = 0 ;
34476
34477   arg1 = (Dali::Actor *)jarg1;
34478   arg2 = (Dali::Vector3 *)jarg2;
34479   if (!arg2) {
34480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34481     return ;
34482   }
34483   {
34484     try {
34485       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34486     } catch (std::out_of_range& e) {
34487       {
34488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34489       };
34490     } catch (std::exception& e) {
34491       {
34492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34493       };
34494     } catch (Dali::DaliException e) {
34495       {
34496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34497       };
34498     } catch (...) {
34499       {
34500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34501       };
34502     }
34503   }
34504
34505 }
34506
34507
34508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34509   void * jresult ;
34510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34511   Dali::Vector3 result;
34512
34513   arg1 = (Dali::Actor *)jarg1;
34514   {
34515     try {
34516       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34517     } catch (std::out_of_range& e) {
34518       {
34519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34520       };
34521     } catch (std::exception& e) {
34522       {
34523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34524       };
34525     } catch (Dali::DaliException e) {
34526       {
34527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34528       };
34529     } catch (...) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34532       };
34533     }
34534   }
34535
34536   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34537   return jresult;
34538 }
34539
34540
34541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34543   Dali::Vector3 *arg2 = 0 ;
34544
34545   arg1 = (Dali::Actor *)jarg1;
34546   arg2 = (Dali::Vector3 *)jarg2;
34547   if (!arg2) {
34548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34549     return ;
34550   }
34551   {
34552     try {
34553       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34554     } catch (std::out_of_range& e) {
34555       {
34556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34557       };
34558     } catch (std::exception& e) {
34559       {
34560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34561       };
34562     } catch (Dali::DaliException e) {
34563       {
34564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34565       };
34566     } catch (...) {
34567       {
34568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34569       };
34570     }
34571   }
34572
34573 }
34574
34575
34576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34577   void * jresult ;
34578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34579   Dali::Vector3 result;
34580
34581   arg1 = (Dali::Actor *)jarg1;
34582   {
34583     try {
34584       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34585     } catch (std::out_of_range& e) {
34586       {
34587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34588       };
34589     } catch (std::exception& e) {
34590       {
34591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34592       };
34593     } catch (Dali::DaliException e) {
34594       {
34595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34596       };
34597     } catch (...) {
34598       {
34599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34600       };
34601     }
34602   }
34603
34604   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34605   return jresult;
34606 }
34607
34608
34609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34610   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34611   float arg2 ;
34612   float arg3 ;
34613
34614   arg1 = (Dali::Actor *)jarg1;
34615   arg2 = (float)jarg2;
34616   arg3 = (float)jarg3;
34617   {
34618     try {
34619       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34620     } catch (std::out_of_range& e) {
34621       {
34622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34623       };
34624     } catch (std::exception& e) {
34625       {
34626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34627       };
34628     } catch (Dali::DaliException e) {
34629       {
34630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34631       };
34632     } catch (...) {
34633       {
34634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34635       };
34636     }
34637   }
34638
34639 }
34640
34641
34642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34644   float arg2 ;
34645   float arg3 ;
34646   float arg4 ;
34647
34648   arg1 = (Dali::Actor *)jarg1;
34649   arg2 = (float)jarg2;
34650   arg3 = (float)jarg3;
34651   arg4 = (float)jarg4;
34652   {
34653     try {
34654       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34655     } catch (std::out_of_range& e) {
34656       {
34657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34658       };
34659     } catch (std::exception& e) {
34660       {
34661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34662       };
34663     } catch (Dali::DaliException e) {
34664       {
34665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34666       };
34667     } catch (...) {
34668       {
34669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34670       };
34671     }
34672   }
34673
34674 }
34675
34676
34677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34678   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34679   Dali::Vector2 *arg2 = 0 ;
34680
34681   arg1 = (Dali::Actor *)jarg1;
34682   arg2 = (Dali::Vector2 *)jarg2;
34683   if (!arg2) {
34684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34685     return ;
34686   }
34687   {
34688     try {
34689       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34690     } catch (std::out_of_range& e) {
34691       {
34692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34693       };
34694     } catch (std::exception& e) {
34695       {
34696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34697       };
34698     } catch (Dali::DaliException e) {
34699       {
34700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34701       };
34702     } catch (...) {
34703       {
34704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34705       };
34706     }
34707   }
34708
34709 }
34710
34711
34712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34714   Dali::Vector3 *arg2 = 0 ;
34715
34716   arg1 = (Dali::Actor *)jarg1;
34717   arg2 = (Dali::Vector3 *)jarg2;
34718   if (!arg2) {
34719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34720     return ;
34721   }
34722   {
34723     try {
34724       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34725     } catch (std::out_of_range& e) {
34726       {
34727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34728       };
34729     } catch (std::exception& e) {
34730       {
34731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34732       };
34733     } catch (Dali::DaliException e) {
34734       {
34735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34736       };
34737     } catch (...) {
34738       {
34739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34740       };
34741     }
34742   }
34743
34744 }
34745
34746
34747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34748   void * jresult ;
34749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34750   Dali::Vector3 result;
34751
34752   arg1 = (Dali::Actor *)jarg1;
34753   {
34754     try {
34755       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34756     } catch (std::out_of_range& e) {
34757       {
34758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34759       };
34760     } catch (std::exception& e) {
34761       {
34762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34763       };
34764     } catch (Dali::DaliException e) {
34765       {
34766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34767       };
34768     } catch (...) {
34769       {
34770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34771       };
34772     }
34773   }
34774
34775   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34776   return jresult;
34777 }
34778
34779
34780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34781   void * jresult ;
34782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34783   Dali::Vector3 result;
34784
34785   arg1 = (Dali::Actor *)jarg1;
34786   {
34787     try {
34788       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34789     } catch (std::out_of_range& e) {
34790       {
34791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34792       };
34793     } catch (std::exception& e) {
34794       {
34795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34796       };
34797     } catch (Dali::DaliException e) {
34798       {
34799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34800       };
34801     } catch (...) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34804       };
34805     }
34806   }
34807
34808   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34809   return jresult;
34810 }
34811
34812
34813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34814   void * jresult ;
34815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34816   Dali::Vector3 result;
34817
34818   arg1 = (Dali::Actor *)jarg1;
34819   {
34820     try {
34821       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34822     } catch (std::out_of_range& e) {
34823       {
34824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34825       };
34826     } catch (std::exception& e) {
34827       {
34828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34829       };
34830     } catch (Dali::DaliException e) {
34831       {
34832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34833       };
34834     } catch (...) {
34835       {
34836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34837       };
34838     }
34839   }
34840
34841   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34842   return jresult;
34843 }
34844
34845
34846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34848   float arg2 ;
34849   float arg3 ;
34850
34851   arg1 = (Dali::Actor *)jarg1;
34852   arg2 = (float)jarg2;
34853   arg3 = (float)jarg3;
34854   {
34855     try {
34856       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34857     } catch (std::out_of_range& e) {
34858       {
34859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34860       };
34861     } catch (std::exception& e) {
34862       {
34863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34864       };
34865     } catch (Dali::DaliException e) {
34866       {
34867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34868       };
34869     } catch (...) {
34870       {
34871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34872       };
34873     }
34874   }
34875
34876 }
34877
34878
34879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34881   float arg2 ;
34882   float arg3 ;
34883   float arg4 ;
34884
34885   arg1 = (Dali::Actor *)jarg1;
34886   arg2 = (float)jarg2;
34887   arg3 = (float)jarg3;
34888   arg4 = (float)jarg4;
34889   {
34890     try {
34891       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34892     } catch (std::out_of_range& e) {
34893       {
34894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34895       };
34896     } catch (std::exception& e) {
34897       {
34898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34899       };
34900     } catch (Dali::DaliException e) {
34901       {
34902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34903       };
34904     } catch (...) {
34905       {
34906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34907       };
34908     }
34909   }
34910
34911 }
34912
34913
34914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34915   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34916   Dali::Vector3 *arg2 = 0 ;
34917
34918   arg1 = (Dali::Actor *)jarg1;
34919   arg2 = (Dali::Vector3 *)jarg2;
34920   if (!arg2) {
34921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34922     return ;
34923   }
34924   {
34925     try {
34926       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34927     } catch (std::out_of_range& e) {
34928       {
34929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34930       };
34931     } catch (std::exception& e) {
34932       {
34933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (Dali::DaliException e) {
34936       {
34937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34938       };
34939     } catch (...) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34942       };
34943     }
34944   }
34945
34946 }
34947
34948
34949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34951   float arg2 ;
34952
34953   arg1 = (Dali::Actor *)jarg1;
34954   arg2 = (float)jarg2;
34955   {
34956     try {
34957       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34958     } catch (std::out_of_range& e) {
34959       {
34960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34961       };
34962     } catch (std::exception& e) {
34963       {
34964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34965       };
34966     } catch (Dali::DaliException e) {
34967       {
34968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34969       };
34970     } catch (...) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34973       };
34974     }
34975   }
34976
34977 }
34978
34979
34980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34982   float arg2 ;
34983
34984   arg1 = (Dali::Actor *)jarg1;
34985   arg2 = (float)jarg2;
34986   {
34987     try {
34988       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34989     } catch (std::out_of_range& e) {
34990       {
34991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (std::exception& e) {
34994       {
34995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34996       };
34997     } catch (Dali::DaliException e) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35000       };
35001     } catch (...) {
35002       {
35003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35004       };
35005     }
35006   }
35007
35008 }
35009
35010
35011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
35012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35013   float arg2 ;
35014
35015   arg1 = (Dali::Actor *)jarg1;
35016   arg2 = (float)jarg2;
35017   {
35018     try {
35019       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
35020     } catch (std::out_of_range& e) {
35021       {
35022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35023       };
35024     } catch (std::exception& e) {
35025       {
35026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (Dali::DaliException e) {
35029       {
35030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35031       };
35032     } catch (...) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35035       };
35036     }
35037   }
35038
35039 }
35040
35041
35042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
35043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35044   Dali::Vector3 *arg2 = 0 ;
35045
35046   arg1 = (Dali::Actor *)jarg1;
35047   arg2 = (Dali::Vector3 *)jarg2;
35048   if (!arg2) {
35049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35050     return ;
35051   }
35052   {
35053     try {
35054       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
35055     } catch (std::out_of_range& e) {
35056       {
35057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35058       };
35059     } catch (std::exception& e) {
35060       {
35061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35062       };
35063     } catch (Dali::DaliException e) {
35064       {
35065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35066       };
35067     } catch (...) {
35068       {
35069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35070       };
35071     }
35072   }
35073
35074 }
35075
35076
35077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
35078   void * jresult ;
35079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35080   Dali::Vector3 result;
35081
35082   arg1 = (Dali::Actor *)jarg1;
35083   {
35084     try {
35085       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
35086     } catch (std::out_of_range& e) {
35087       {
35088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35089       };
35090     } catch (std::exception& e) {
35091       {
35092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35093       };
35094     } catch (Dali::DaliException e) {
35095       {
35096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35097       };
35098     } catch (...) {
35099       {
35100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35101       };
35102     }
35103   }
35104
35105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35106   return jresult;
35107 }
35108
35109
35110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
35111   void * jresult ;
35112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35113   Dali::Vector3 result;
35114
35115   arg1 = (Dali::Actor *)jarg1;
35116   {
35117     try {
35118       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
35119     } catch (std::out_of_range& e) {
35120       {
35121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35122       };
35123     } catch (std::exception& e) {
35124       {
35125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35126       };
35127     } catch (Dali::DaliException e) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35134       };
35135     }
35136   }
35137
35138   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35139   return jresult;
35140 }
35141
35142
35143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
35144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35145   bool arg2 ;
35146
35147   arg1 = (Dali::Actor *)jarg1;
35148   arg2 = jarg2 ? true : false;
35149   {
35150     try {
35151       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
35152     } catch (std::out_of_range& e) {
35153       {
35154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35155       };
35156     } catch (std::exception& e) {
35157       {
35158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35159       };
35160     } catch (Dali::DaliException e) {
35161       {
35162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35163       };
35164     } catch (...) {
35165       {
35166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35167       };
35168     }
35169   }
35170
35171 }
35172
35173
35174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35175   unsigned int jresult ;
35176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35177   bool result;
35178
35179   arg1 = (Dali::Actor *)jarg1;
35180   {
35181     try {
35182       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35183     } catch (std::out_of_range& e) {
35184       {
35185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35186       };
35187     } catch (std::exception& e) {
35188       {
35189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35190       };
35191     } catch (Dali::DaliException e) {
35192       {
35193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35194       };
35195     } catch (...) {
35196       {
35197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35198       };
35199     }
35200   }
35201
35202   jresult = result;
35203   return jresult;
35204 }
35205
35206
35207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35209   Dali::Degree *arg2 = 0 ;
35210   Dali::Vector3 *arg3 = 0 ;
35211
35212   arg1 = (Dali::Actor *)jarg1;
35213   arg2 = (Dali::Degree *)jarg2;
35214   if (!arg2) {
35215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35216     return ;
35217   }
35218   arg3 = (Dali::Vector3 *)jarg3;
35219   if (!arg3) {
35220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35221     return ;
35222   }
35223   {
35224     try {
35225       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35226     } catch (std::out_of_range& e) {
35227       {
35228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35229       };
35230     } catch (std::exception& e) {
35231       {
35232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35233       };
35234     } catch (Dali::DaliException e) {
35235       {
35236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35237       };
35238     } catch (...) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35241       };
35242     }
35243   }
35244
35245 }
35246
35247
35248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35249   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35250   Dali::Radian *arg2 = 0 ;
35251   Dali::Vector3 *arg3 = 0 ;
35252
35253   arg1 = (Dali::Actor *)jarg1;
35254   arg2 = (Dali::Radian *)jarg2;
35255   if (!arg2) {
35256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35257     return ;
35258   }
35259   arg3 = (Dali::Vector3 *)jarg3;
35260   if (!arg3) {
35261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35262     return ;
35263   }
35264   {
35265     try {
35266       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35267     } catch (std::out_of_range& e) {
35268       {
35269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (std::exception& e) {
35272       {
35273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (Dali::DaliException e) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35278       };
35279     } catch (...) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35282       };
35283     }
35284   }
35285
35286 }
35287
35288
35289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35291   Dali::Quaternion *arg2 = 0 ;
35292
35293   arg1 = (Dali::Actor *)jarg1;
35294   arg2 = (Dali::Quaternion *)jarg2;
35295   if (!arg2) {
35296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35297     return ;
35298   }
35299   {
35300     try {
35301       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35302     } catch (std::out_of_range& e) {
35303       {
35304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (std::exception& e) {
35307       {
35308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35309       };
35310     } catch (Dali::DaliException e) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35317       };
35318     }
35319   }
35320
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35326   Dali::Degree *arg2 = 0 ;
35327   Dali::Vector3 *arg3 = 0 ;
35328
35329   arg1 = (Dali::Actor *)jarg1;
35330   arg2 = (Dali::Degree *)jarg2;
35331   if (!arg2) {
35332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35333     return ;
35334   }
35335   arg3 = (Dali::Vector3 *)jarg3;
35336   if (!arg3) {
35337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35338     return ;
35339   }
35340   {
35341     try {
35342       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35343     } catch (std::out_of_range& e) {
35344       {
35345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35346       };
35347     } catch (std::exception& e) {
35348       {
35349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35350       };
35351     } catch (Dali::DaliException e) {
35352       {
35353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35354       };
35355     } catch (...) {
35356       {
35357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35358       };
35359     }
35360   }
35361
35362 }
35363
35364
35365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35367   Dali::Radian *arg2 = 0 ;
35368   Dali::Vector3 *arg3 = 0 ;
35369
35370   arg1 = (Dali::Actor *)jarg1;
35371   arg2 = (Dali::Radian *)jarg2;
35372   if (!arg2) {
35373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35374     return ;
35375   }
35376   arg3 = (Dali::Vector3 *)jarg3;
35377   if (!arg3) {
35378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35379     return ;
35380   }
35381   {
35382     try {
35383       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35384     } catch (std::out_of_range& e) {
35385       {
35386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35387       };
35388     } catch (std::exception& e) {
35389       {
35390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35391       };
35392     } catch (Dali::DaliException e) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35395       };
35396     } catch (...) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35399       };
35400     }
35401   }
35402
35403 }
35404
35405
35406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35408   Dali::Quaternion *arg2 = 0 ;
35409
35410   arg1 = (Dali::Actor *)jarg1;
35411   arg2 = (Dali::Quaternion *)jarg2;
35412   if (!arg2) {
35413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35414     return ;
35415   }
35416   {
35417     try {
35418       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35419     } catch (std::out_of_range& e) {
35420       {
35421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35422       };
35423     } catch (std::exception& e) {
35424       {
35425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35426       };
35427     } catch (Dali::DaliException e) {
35428       {
35429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35430       };
35431     } catch (...) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35434       };
35435     }
35436   }
35437
35438 }
35439
35440
35441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35442   void * jresult ;
35443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35444   Dali::Quaternion result;
35445
35446   arg1 = (Dali::Actor *)jarg1;
35447   {
35448     try {
35449       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35450     } catch (std::out_of_range& e) {
35451       {
35452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35453       };
35454     } catch (std::exception& e) {
35455       {
35456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35457       };
35458     } catch (Dali::DaliException e) {
35459       {
35460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35461       };
35462     } catch (...) {
35463       {
35464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35465       };
35466     }
35467   }
35468
35469   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35470   return jresult;
35471 }
35472
35473
35474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35476   bool arg2 ;
35477
35478   arg1 = (Dali::Actor *)jarg1;
35479   arg2 = jarg2 ? true : false;
35480   {
35481     try {
35482       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35483     } catch (std::out_of_range& e) {
35484       {
35485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35486       };
35487     } catch (std::exception& e) {
35488       {
35489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35490       };
35491     } catch (Dali::DaliException e) {
35492       {
35493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35498       };
35499     }
35500   }
35501
35502 }
35503
35504
35505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35506   unsigned int jresult ;
35507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35508   bool result;
35509
35510   arg1 = (Dali::Actor *)jarg1;
35511   {
35512     try {
35513       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35514     } catch (std::out_of_range& e) {
35515       {
35516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35517       };
35518     } catch (std::exception& e) {
35519       {
35520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35521       };
35522     } catch (Dali::DaliException e) {
35523       {
35524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35525       };
35526     } catch (...) {
35527       {
35528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35529       };
35530     }
35531   }
35532
35533   jresult = result;
35534   return jresult;
35535 }
35536
35537
35538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35539   void * jresult ;
35540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35541   Dali::Quaternion result;
35542
35543   arg1 = (Dali::Actor *)jarg1;
35544   {
35545     try {
35546       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35547     } catch (std::out_of_range& e) {
35548       {
35549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (std::exception& e) {
35552       {
35553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35554       };
35555     } catch (Dali::DaliException e) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35558       };
35559     } catch (...) {
35560       {
35561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35562       };
35563     }
35564   }
35565
35566   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35567   return jresult;
35568 }
35569
35570
35571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35573   float arg2 ;
35574
35575   arg1 = (Dali::Actor *)jarg1;
35576   arg2 = (float)jarg2;
35577   {
35578     try {
35579       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35580     } catch (std::out_of_range& e) {
35581       {
35582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35583       };
35584     } catch (std::exception& e) {
35585       {
35586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35587       };
35588     } catch (Dali::DaliException e) {
35589       {
35590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35591       };
35592     } catch (...) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35595       };
35596     }
35597   }
35598
35599 }
35600
35601
35602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35604   float arg2 ;
35605   float arg3 ;
35606   float arg4 ;
35607
35608   arg1 = (Dali::Actor *)jarg1;
35609   arg2 = (float)jarg2;
35610   arg3 = (float)jarg3;
35611   arg4 = (float)jarg4;
35612   {
35613     try {
35614       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35622       };
35623     } catch (Dali::DaliException e) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35626       };
35627     } catch (...) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35630       };
35631     }
35632   }
35633
35634 }
35635
35636
35637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35639   Dali::Vector3 *arg2 = 0 ;
35640
35641   arg1 = (Dali::Actor *)jarg1;
35642   arg2 = (Dali::Vector3 *)jarg2;
35643   if (!arg2) {
35644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35645     return ;
35646   }
35647   {
35648     try {
35649       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35650     } catch (std::out_of_range& e) {
35651       {
35652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35653       };
35654     } catch (std::exception& e) {
35655       {
35656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35657       };
35658     } catch (Dali::DaliException e) {
35659       {
35660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35661       };
35662     } catch (...) {
35663       {
35664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35665       };
35666     }
35667   }
35668
35669 }
35670
35671
35672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35674   Dali::Vector3 *arg2 = 0 ;
35675
35676   arg1 = (Dali::Actor *)jarg1;
35677   arg2 = (Dali::Vector3 *)jarg2;
35678   if (!arg2) {
35679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35680     return ;
35681   }
35682   {
35683     try {
35684       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35685     } catch (std::out_of_range& e) {
35686       {
35687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35688       };
35689     } catch (std::exception& e) {
35690       {
35691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35692       };
35693     } catch (Dali::DaliException e) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35696       };
35697     } catch (...) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35700       };
35701     }
35702   }
35703
35704 }
35705
35706
35707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35708   void * jresult ;
35709   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35710   Dali::Vector3 result;
35711
35712   arg1 = (Dali::Actor *)jarg1;
35713   {
35714     try {
35715       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35716     } catch (std::out_of_range& e) {
35717       {
35718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35719       };
35720     } catch (std::exception& e) {
35721       {
35722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35723       };
35724     } catch (Dali::DaliException e) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35727       };
35728     } catch (...) {
35729       {
35730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35731       };
35732     }
35733   }
35734
35735   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35736   return jresult;
35737 }
35738
35739
35740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35741   void * jresult ;
35742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35743   Dali::Vector3 result;
35744
35745   arg1 = (Dali::Actor *)jarg1;
35746   {
35747     try {
35748       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35749     } catch (std::out_of_range& e) {
35750       {
35751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35752       };
35753     } catch (std::exception& e) {
35754       {
35755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (Dali::DaliException e) {
35758       {
35759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35760       };
35761     } catch (...) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35764       };
35765     }
35766   }
35767
35768   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35769   return jresult;
35770 }
35771
35772
35773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35774   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35775   bool arg2 ;
35776
35777   arg1 = (Dali::Actor *)jarg1;
35778   arg2 = jarg2 ? true : false;
35779   {
35780     try {
35781       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35782     } catch (std::out_of_range& e) {
35783       {
35784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35785       };
35786     } catch (std::exception& e) {
35787       {
35788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35789       };
35790     } catch (Dali::DaliException e) {
35791       {
35792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35793       };
35794     } catch (...) {
35795       {
35796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35797       };
35798     }
35799   }
35800
35801 }
35802
35803
35804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35805   unsigned int jresult ;
35806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35807   bool result;
35808
35809   arg1 = (Dali::Actor *)jarg1;
35810   {
35811     try {
35812       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35813     } catch (std::out_of_range& e) {
35814       {
35815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35816       };
35817     } catch (std::exception& e) {
35818       {
35819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35820       };
35821     } catch (Dali::DaliException e) {
35822       {
35823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35824       };
35825     } catch (...) {
35826       {
35827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35828       };
35829     }
35830   }
35831
35832   jresult = result;
35833   return jresult;
35834 }
35835
35836
35837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35838   void * jresult ;
35839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35840   Dali::Matrix result;
35841
35842   arg1 = (Dali::Actor *)jarg1;
35843   {
35844     try {
35845       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35846     } catch (std::out_of_range& e) {
35847       {
35848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35849       };
35850     } catch (std::exception& e) {
35851       {
35852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35853       };
35854     } catch (Dali::DaliException e) {
35855       {
35856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35857       };
35858     } catch (...) {
35859       {
35860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35861       };
35862     }
35863   }
35864
35865   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35866   return jresult;
35867 }
35868
35869
35870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35872   bool arg2 ;
35873
35874   arg1 = (Dali::Actor *)jarg1;
35875   arg2 = jarg2 ? true : false;
35876   {
35877     try {
35878       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35879     } catch (std::out_of_range& e) {
35880       {
35881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35882       };
35883     } catch (std::exception& e) {
35884       {
35885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35886       };
35887     } catch (Dali::DaliException e) {
35888       {
35889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35890       };
35891     } catch (...) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35894       };
35895     }
35896   }
35897
35898 }
35899
35900
35901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35902   unsigned int jresult ;
35903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35904   bool result;
35905
35906   arg1 = (Dali::Actor *)jarg1;
35907   {
35908     try {
35909       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35910     } catch (std::out_of_range& e) {
35911       {
35912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35913       };
35914     } catch (std::exception& e) {
35915       {
35916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35917       };
35918     } catch (Dali::DaliException e) {
35919       {
35920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35921       };
35922     } catch (...) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35925       };
35926     }
35927   }
35928
35929   jresult = result;
35930   return jresult;
35931 }
35932
35933
35934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35936   float arg2 ;
35937
35938   arg1 = (Dali::Actor *)jarg1;
35939   arg2 = (float)jarg2;
35940   {
35941     try {
35942       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35943     } catch (std::out_of_range& e) {
35944       {
35945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35946       };
35947     } catch (std::exception& e) {
35948       {
35949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35950       };
35951     } catch (Dali::DaliException e) {
35952       {
35953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35954       };
35955     } catch (...) {
35956       {
35957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35958       };
35959     }
35960   }
35961
35962 }
35963
35964
35965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35966   float jresult ;
35967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35968   float result;
35969
35970   arg1 = (Dali::Actor *)jarg1;
35971   {
35972     try {
35973       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35974     } catch (std::out_of_range& e) {
35975       {
35976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35977       };
35978     } catch (std::exception& e) {
35979       {
35980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35981       };
35982     } catch (Dali::DaliException e) {
35983       {
35984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35985       };
35986     } catch (...) {
35987       {
35988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35989       };
35990     }
35991   }
35992
35993   jresult = result;
35994   return jresult;
35995 }
35996
35997
35998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36000   Dali::Vector4 *arg2 = 0 ;
36001
36002   arg1 = (Dali::Actor *)jarg1;
36003   arg2 = (Dali::Vector4 *)jarg2;
36004   if (!arg2) {
36005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
36006     return ;
36007   }
36008   {
36009     try {
36010       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
36011     } catch (std::out_of_range& e) {
36012       {
36013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36014       };
36015     } catch (std::exception& e) {
36016       {
36017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (Dali::DaliException e) {
36020       {
36021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36022       };
36023     } catch (...) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36026       };
36027     }
36028   }
36029
36030 }
36031
36032
36033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
36034   void * jresult ;
36035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36036   Dali::Vector4 result;
36037
36038   arg1 = (Dali::Actor *)jarg1;
36039   {
36040     try {
36041       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
36042     } catch (std::out_of_range& e) {
36043       {
36044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36045       };
36046     } catch (std::exception& e) {
36047       {
36048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (Dali::DaliException e) {
36051       {
36052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36053       };
36054     } catch (...) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36057       };
36058     }
36059   }
36060
36061   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36062   return jresult;
36063 }
36064
36065
36066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
36067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36068   Dali::ColorMode arg2 ;
36069
36070   arg1 = (Dali::Actor *)jarg1;
36071   arg2 = (Dali::ColorMode)jarg2;
36072   {
36073     try {
36074       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
36075     } catch (std::out_of_range& e) {
36076       {
36077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36078       };
36079     } catch (std::exception& e) {
36080       {
36081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36082       };
36083     } catch (Dali::DaliException e) {
36084       {
36085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36086       };
36087     } catch (...) {
36088       {
36089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36090       };
36091     }
36092   }
36093
36094 }
36095
36096
36097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
36098   int jresult ;
36099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36100   Dali::ColorMode result;
36101
36102   arg1 = (Dali::Actor *)jarg1;
36103   {
36104     try {
36105       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
36106     } catch (std::out_of_range& e) {
36107       {
36108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36109       };
36110     } catch (std::exception& e) {
36111       {
36112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36113       };
36114     } catch (Dali::DaliException e) {
36115       {
36116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36117       };
36118     } catch (...) {
36119       {
36120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36121       };
36122     }
36123   }
36124
36125   jresult = (int)result;
36126   return jresult;
36127 }
36128
36129
36130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
36131   void * jresult ;
36132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36133   Dali::Vector4 result;
36134
36135   arg1 = (Dali::Actor *)jarg1;
36136   {
36137     try {
36138       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
36139     } catch (std::out_of_range& e) {
36140       {
36141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36142       };
36143     } catch (std::exception& e) {
36144       {
36145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36146       };
36147     } catch (Dali::DaliException e) {
36148       {
36149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36150       };
36151     } catch (...) {
36152       {
36153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36154       };
36155     }
36156   }
36157
36158   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36159   return jresult;
36160 }
36161
36162
36163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36165   Dali::DrawMode::Type arg2 ;
36166
36167   arg1 = (Dali::Actor *)jarg1;
36168   arg2 = (Dali::DrawMode::Type)jarg2;
36169   {
36170     try {
36171       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
36172     } catch (std::out_of_range& e) {
36173       {
36174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36175       };
36176     } catch (std::exception& e) {
36177       {
36178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36179       };
36180     } catch (Dali::DaliException e) {
36181       {
36182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36183       };
36184     } catch (...) {
36185       {
36186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36187       };
36188     }
36189   }
36190
36191 }
36192
36193
36194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36195   int jresult ;
36196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36197   Dali::DrawMode::Type result;
36198
36199   arg1 = (Dali::Actor *)jarg1;
36200   {
36201     try {
36202       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36203     } catch (std::out_of_range& e) {
36204       {
36205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36206       };
36207     } catch (std::exception& e) {
36208       {
36209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36210       };
36211     } catch (Dali::DaliException e) {
36212       {
36213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36214       };
36215     } catch (...) {
36216       {
36217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36218       };
36219     }
36220   }
36221
36222   jresult = (int)result;
36223   return jresult;
36224 }
36225
36226
36227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36229   bool arg2 ;
36230
36231   arg1 = (Dali::Actor *)jarg1;
36232   arg2 = jarg2 ? true : false;
36233   {
36234     try {
36235       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36236     } catch (std::out_of_range& e) {
36237       {
36238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36239       };
36240     } catch (std::exception& e) {
36241       {
36242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36243       };
36244     } catch (Dali::DaliException e) {
36245       {
36246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36247       };
36248     } catch (...) {
36249       {
36250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36251       };
36252     }
36253   }
36254
36255 }
36256
36257
36258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36259   unsigned int jresult ;
36260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36261   bool result;
36262
36263   arg1 = (Dali::Actor *)jarg1;
36264   {
36265     try {
36266       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36267     } catch (std::out_of_range& e) {
36268       {
36269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36270       };
36271     } catch (std::exception& e) {
36272       {
36273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36274       };
36275     } catch (Dali::DaliException e) {
36276       {
36277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36278       };
36279     } catch (...) {
36280       {
36281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36282       };
36283     }
36284   }
36285
36286   jresult = result;
36287   return jresult;
36288 }
36289
36290
36291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36292   unsigned int jresult ;
36293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36294   float *arg2 = 0 ;
36295   float *arg3 = 0 ;
36296   float arg4 ;
36297   float arg5 ;
36298   bool result;
36299
36300   arg1 = (Dali::Actor *)jarg1;
36301   arg2 = (float *)jarg2;
36302   arg3 = (float *)jarg3;
36303   arg4 = (float)jarg4;
36304   arg5 = (float)jarg5;
36305   {
36306     try {
36307       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36308     } catch (std::out_of_range& e) {
36309       {
36310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36311       };
36312     } catch (std::exception& e) {
36313       {
36314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36315       };
36316     } catch (Dali::DaliException e) {
36317       {
36318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36319       };
36320     } catch (...) {
36321       {
36322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36323       };
36324     }
36325   }
36326
36327   jresult = result;
36328   return jresult;
36329 }
36330
36331
36332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36334   bool arg2 ;
36335
36336   arg1 = (Dali::Actor *)jarg1;
36337   arg2 = jarg2 ? true : false;
36338   {
36339     try {
36340       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36341     } catch (std::out_of_range& e) {
36342       {
36343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36344       };
36345     } catch (std::exception& e) {
36346       {
36347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36348       };
36349     } catch (Dali::DaliException e) {
36350       {
36351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36352       };
36353     } catch (...) {
36354       {
36355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36356       };
36357     }
36358   }
36359
36360 }
36361
36362
36363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36364   unsigned int jresult ;
36365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36366   bool result;
36367
36368   arg1 = (Dali::Actor *)jarg1;
36369   {
36370     try {
36371       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36372     } catch (std::out_of_range& e) {
36373       {
36374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36375       };
36376     } catch (std::exception& e) {
36377       {
36378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36379       };
36380     } catch (Dali::DaliException e) {
36381       {
36382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36383       };
36384     } catch (...) {
36385       {
36386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36387       };
36388     }
36389   }
36390
36391   jresult = result;
36392   return jresult;
36393 }
36394
36395
36396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36398   bool arg2 ;
36399
36400   arg1 = (Dali::Actor *)jarg1;
36401   arg2 = jarg2 ? true : false;
36402   {
36403     try {
36404       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36405     } catch (std::out_of_range& e) {
36406       {
36407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36408       };
36409     } catch (std::exception& e) {
36410       {
36411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36412       };
36413     } catch (Dali::DaliException e) {
36414       {
36415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36416       };
36417     } catch (...) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36420       };
36421     }
36422   }
36423
36424 }
36425
36426
36427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36428   unsigned int jresult ;
36429   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36430   bool result;
36431
36432   arg1 = (Dali::Actor *)jarg1;
36433   {
36434     try {
36435       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36436     } catch (std::out_of_range& e) {
36437       {
36438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36439       };
36440     } catch (std::exception& e) {
36441       {
36442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36443       };
36444     } catch (Dali::DaliException e) {
36445       {
36446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36447       };
36448     } catch (...) {
36449       {
36450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36451       };
36452     }
36453   }
36454
36455   jresult = result;
36456   return jresult;
36457 }
36458
36459
36460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36462   Dali::ResizePolicy::Type arg2 ;
36463   Dali::Dimension::Type arg3 ;
36464
36465   arg1 = (Dali::Actor *)jarg1;
36466   arg2 = (Dali::ResizePolicy::Type)jarg2;
36467   arg3 = (Dali::Dimension::Type)jarg3;
36468   {
36469     try {
36470       (arg1)->SetResizePolicy(arg2,arg3);
36471     } catch (std::out_of_range& e) {
36472       {
36473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36474       };
36475     } catch (std::exception& e) {
36476       {
36477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36478       };
36479     } catch (Dali::DaliException e) {
36480       {
36481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36482       };
36483     } catch (...) {
36484       {
36485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36486       };
36487     }
36488   }
36489
36490 }
36491
36492
36493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36494   int jresult ;
36495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36496   Dali::Dimension::Type arg2 ;
36497   Dali::ResizePolicy::Type result;
36498
36499   arg1 = (Dali::Actor *)jarg1;
36500   arg2 = (Dali::Dimension::Type)jarg2;
36501   {
36502     try {
36503       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36504     } catch (std::out_of_range& e) {
36505       {
36506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36507       };
36508     } catch (std::exception& e) {
36509       {
36510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36511       };
36512     } catch (Dali::DaliException e) {
36513       {
36514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36515       };
36516     } catch (...) {
36517       {
36518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36519       };
36520     }
36521   }
36522
36523   jresult = (int)result;
36524   return jresult;
36525 }
36526
36527
36528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36530   Dali::SizeScalePolicy::Type arg2 ;
36531
36532   arg1 = (Dali::Actor *)jarg1;
36533   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36534   {
36535     try {
36536       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36537     } catch (std::out_of_range& e) {
36538       {
36539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36540       };
36541     } catch (std::exception& e) {
36542       {
36543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36544       };
36545     } catch (Dali::DaliException e) {
36546       {
36547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36548       };
36549     } catch (...) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36552       };
36553     }
36554   }
36555
36556 }
36557
36558
36559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36560   int jresult ;
36561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36562   Dali::SizeScalePolicy::Type result;
36563
36564   arg1 = (Dali::Actor *)jarg1;
36565   {
36566     try {
36567       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36568     } catch (std::out_of_range& e) {
36569       {
36570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36571       };
36572     } catch (std::exception& e) {
36573       {
36574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36575       };
36576     } catch (Dali::DaliException e) {
36577       {
36578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36579       };
36580     } catch (...) {
36581       {
36582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36583       };
36584     }
36585   }
36586
36587   jresult = (int)result;
36588   return jresult;
36589 }
36590
36591
36592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36594   Dali::Vector3 *arg2 = 0 ;
36595
36596   arg1 = (Dali::Actor *)jarg1;
36597   arg2 = (Dali::Vector3 *)jarg2;
36598   if (!arg2) {
36599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36600     return ;
36601   }
36602   {
36603     try {
36604       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36605     } catch (std::out_of_range& e) {
36606       {
36607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36608       };
36609     } catch (std::exception& e) {
36610       {
36611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36612       };
36613     } catch (Dali::DaliException e) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36616       };
36617     } catch (...) {
36618       {
36619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36620       };
36621     }
36622   }
36623
36624 }
36625
36626
36627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36628   void * jresult ;
36629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36630   Dali::Vector3 result;
36631
36632   arg1 = (Dali::Actor *)jarg1;
36633   {
36634     try {
36635       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36636     } catch (std::out_of_range& e) {
36637       {
36638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36639       };
36640     } catch (std::exception& e) {
36641       {
36642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36643       };
36644     } catch (Dali::DaliException e) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36647       };
36648     } catch (...) {
36649       {
36650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36651       };
36652     }
36653   }
36654
36655   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36656   return jresult;
36657 }
36658
36659
36660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36661   float jresult ;
36662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36663   float arg2 ;
36664   float result;
36665
36666   arg1 = (Dali::Actor *)jarg1;
36667   arg2 = (float)jarg2;
36668   {
36669     try {
36670       result = (float)(arg1)->GetHeightForWidth(arg2);
36671     } catch (std::out_of_range& e) {
36672       {
36673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36674       };
36675     } catch (std::exception& e) {
36676       {
36677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36678       };
36679     } catch (Dali::DaliException e) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36682       };
36683     } catch (...) {
36684       {
36685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36686       };
36687     }
36688   }
36689
36690   jresult = result;
36691   return jresult;
36692 }
36693
36694
36695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36696   float jresult ;
36697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36698   float arg2 ;
36699   float result;
36700
36701   arg1 = (Dali::Actor *)jarg1;
36702   arg2 = (float)jarg2;
36703   {
36704     try {
36705       result = (float)(arg1)->GetWidthForHeight(arg2);
36706     } catch (std::out_of_range& e) {
36707       {
36708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36709       };
36710     } catch (std::exception& e) {
36711       {
36712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36713       };
36714     } catch (Dali::DaliException e) {
36715       {
36716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36717       };
36718     } catch (...) {
36719       {
36720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36721       };
36722     }
36723   }
36724
36725   jresult = result;
36726   return jresult;
36727 }
36728
36729
36730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36731   float jresult ;
36732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36733   Dali::Dimension::Type arg2 ;
36734   float result;
36735
36736   arg1 = (Dali::Actor *)jarg1;
36737   arg2 = (Dali::Dimension::Type)jarg2;
36738   {
36739     try {
36740       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36741     } catch (std::out_of_range& e) {
36742       {
36743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36744       };
36745     } catch (std::exception& e) {
36746       {
36747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36748       };
36749     } catch (Dali::DaliException e) {
36750       {
36751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36752       };
36753     } catch (...) {
36754       {
36755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36756       };
36757     }
36758   }
36759
36760   jresult = result;
36761   return jresult;
36762 }
36763
36764
36765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36767   Dali::Padding *arg2 = 0 ;
36768
36769   arg1 = (Dali::Actor *)jarg1;
36770   arg2 = (Dali::Padding *)jarg2;
36771   if (!arg2) {
36772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36773     return ;
36774   }
36775   {
36776     try {
36777       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36778     } catch (std::out_of_range& e) {
36779       {
36780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36781       };
36782     } catch (std::exception& e) {
36783       {
36784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36785       };
36786     } catch (Dali::DaliException e) {
36787       {
36788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36789       };
36790     } catch (...) {
36791       {
36792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36793       };
36794     }
36795   }
36796
36797 }
36798
36799
36800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36802   Dali::Padding *arg2 = 0 ;
36803
36804   arg1 = (Dali::Actor *)jarg1;
36805   arg2 = (Dali::Padding *)jarg2;
36806   if (!arg2) {
36807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36808     return ;
36809   }
36810   {
36811     try {
36812       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36813     } catch (std::out_of_range& e) {
36814       {
36815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36816       };
36817     } catch (std::exception& e) {
36818       {
36819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36820       };
36821     } catch (Dali::DaliException e) {
36822       {
36823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36824       };
36825     } catch (...) {
36826       {
36827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36828       };
36829     }
36830   }
36831
36832 }
36833
36834
36835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36837   Dali::Vector2 *arg2 = 0 ;
36838
36839   arg1 = (Dali::Actor *)jarg1;
36840   arg2 = (Dali::Vector2 *)jarg2;
36841   if (!arg2) {
36842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36843     return ;
36844   }
36845   {
36846     try {
36847       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36848     } catch (std::out_of_range& e) {
36849       {
36850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36851       };
36852     } catch (std::exception& e) {
36853       {
36854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36855       };
36856     } catch (Dali::DaliException e) {
36857       {
36858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36859       };
36860     } catch (...) {
36861       {
36862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36863       };
36864     }
36865   }
36866
36867 }
36868
36869
36870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36871   void * jresult ;
36872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36873   Dali::Vector2 result;
36874
36875   arg1 = (Dali::Actor *)jarg1;
36876   {
36877     try {
36878       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36879     } catch (std::out_of_range& e) {
36880       {
36881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36882       };
36883     } catch (std::exception& e) {
36884       {
36885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36886       };
36887     } catch (Dali::DaliException e) {
36888       {
36889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36890       };
36891     } catch (...) {
36892       {
36893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36894       };
36895     }
36896   }
36897
36898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36899   return jresult;
36900 }
36901
36902
36903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36905   Dali::Vector2 *arg2 = 0 ;
36906
36907   arg1 = (Dali::Actor *)jarg1;
36908   arg2 = (Dali::Vector2 *)jarg2;
36909   if (!arg2) {
36910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36911     return ;
36912   }
36913   {
36914     try {
36915       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36916     } catch (std::out_of_range& e) {
36917       {
36918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36919       };
36920     } catch (std::exception& e) {
36921       {
36922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36923       };
36924     } catch (Dali::DaliException e) {
36925       {
36926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36927       };
36928     } catch (...) {
36929       {
36930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36931       };
36932     }
36933   }
36934
36935 }
36936
36937
36938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36939   void * jresult ;
36940   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36941   Dali::Vector2 result;
36942
36943   arg1 = (Dali::Actor *)jarg1;
36944   {
36945     try {
36946       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36947     } catch (std::out_of_range& e) {
36948       {
36949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36950       };
36951     } catch (std::exception& e) {
36952       {
36953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36954       };
36955     } catch (Dali::DaliException e) {
36956       {
36957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36958       };
36959     } catch (...) {
36960       {
36961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36962       };
36963     }
36964   }
36965
36966   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36967   return jresult;
36968 }
36969
36970
36971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36972   int jresult ;
36973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36974   int result;
36975
36976   arg1 = (Dali::Actor *)jarg1;
36977   {
36978     try {
36979       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36980       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36981     } catch (std::out_of_range& e) {
36982       {
36983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36984       };
36985     } catch (std::exception& e) {
36986       {
36987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36988       };
36989     } catch (Dali::DaliException e) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36992       };
36993     } catch (...) {
36994       {
36995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36996       };
36997     }
36998   }
36999
37000   jresult = result;
37001   return jresult;
37002 }
37003
37004
37005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
37006   unsigned int jresult ;
37007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37008   Dali::Renderer *arg2 = 0 ;
37009   unsigned int result;
37010
37011   arg1 = (Dali::Actor *)jarg1;
37012   arg2 = (Dali::Renderer *)jarg2;
37013   if (!arg2) {
37014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
37015     return 0;
37016   }
37017   {
37018     try {
37019       result = (unsigned int)(arg1)->AddRenderer(*arg2);
37020     } catch (std::out_of_range& e) {
37021       {
37022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (std::exception& e) {
37025       {
37026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37027       };
37028     } catch (Dali::DaliException e) {
37029       {
37030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37031       };
37032     } catch (...) {
37033       {
37034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37035       };
37036     }
37037   }
37038
37039   jresult = result;
37040   return jresult;
37041 }
37042
37043
37044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
37045   unsigned int jresult ;
37046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37047   unsigned int result;
37048
37049   arg1 = (Dali::Actor *)jarg1;
37050   {
37051     try {
37052       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
37053     } catch (std::out_of_range& e) {
37054       {
37055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37056       };
37057     } catch (std::exception& e) {
37058       {
37059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37060       };
37061     } catch (Dali::DaliException e) {
37062       {
37063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37064       };
37065     } catch (...) {
37066       {
37067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37068       };
37069     }
37070   }
37071
37072   jresult = result;
37073   return jresult;
37074 }
37075
37076
37077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
37078   void * jresult ;
37079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37080   unsigned int arg2 ;
37081   Dali::Renderer result;
37082
37083   arg1 = (Dali::Actor *)jarg1;
37084   arg2 = (unsigned int)jarg2;
37085   {
37086     try {
37087       result = (arg1)->GetRendererAt(arg2);
37088     } catch (std::out_of_range& e) {
37089       {
37090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37091       };
37092     } catch (std::exception& e) {
37093       {
37094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37095       };
37096     } catch (Dali::DaliException e) {
37097       {
37098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37099       };
37100     } catch (...) {
37101       {
37102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37103       };
37104     }
37105   }
37106
37107   jresult = new Dali::Renderer((const Dali::Renderer &)result);
37108   return jresult;
37109 }
37110
37111
37112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
37113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37114   Dali::Renderer *arg2 = 0 ;
37115
37116   arg1 = (Dali::Actor *)jarg1;
37117   arg2 = (Dali::Renderer *)jarg2;
37118   if (!arg2) {
37119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
37120     return ;
37121   }
37122   {
37123     try {
37124       (arg1)->RemoveRenderer(*arg2);
37125     } catch (std::out_of_range& e) {
37126       {
37127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37128       };
37129     } catch (std::exception& e) {
37130       {
37131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37132       };
37133     } catch (Dali::DaliException e) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37136       };
37137     } catch (...) {
37138       {
37139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37140       };
37141     }
37142   }
37143
37144 }
37145
37146
37147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
37148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37149   unsigned int arg2 ;
37150
37151   arg1 = (Dali::Actor *)jarg1;
37152   arg2 = (unsigned int)jarg2;
37153   {
37154     try {
37155       (arg1)->RemoveRenderer(arg2);
37156     } catch (std::out_of_range& e) {
37157       {
37158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37159       };
37160     } catch (std::exception& e) {
37161       {
37162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37163       };
37164     } catch (Dali::DaliException e) {
37165       {
37166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37167       };
37168     } catch (...) {
37169       {
37170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37171       };
37172     }
37173   }
37174
37175 }
37176
37177
37178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37179   void * jresult ;
37180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37181   Dali::Actor::TouchEventSignalType *result = 0 ;
37182
37183   arg1 = (Dali::Actor *)jarg1;
37184   {
37185     try {
37186       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
37187     } catch (std::out_of_range& e) {
37188       {
37189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37190       };
37191     } catch (std::exception& e) {
37192       {
37193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (Dali::DaliException e) {
37196       {
37197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205
37206   jresult = (void *)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37212   void * jresult ;
37213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37214   Dali::Actor::HoverSignalType *result = 0 ;
37215
37216   arg1 = (Dali::Actor *)jarg1;
37217   {
37218     try {
37219       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37220     } catch (std::out_of_range& e) {
37221       {
37222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37223       };
37224     } catch (std::exception& e) {
37225       {
37226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37227       };
37228     } catch (Dali::DaliException e) {
37229       {
37230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37231       };
37232     } catch (...) {
37233       {
37234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37235       };
37236     }
37237   }
37238
37239   jresult = (void *)result;
37240   return jresult;
37241 }
37242
37243
37244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37245   void * jresult ;
37246   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37247   Dali::Actor::WheelEventSignalType *result = 0 ;
37248
37249   arg1 = (Dali::Actor *)jarg1;
37250   {
37251     try {
37252       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37253     } catch (std::out_of_range& e) {
37254       {
37255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (std::exception& e) {
37258       {
37259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37260       };
37261     } catch (Dali::DaliException e) {
37262       {
37263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37264       };
37265     } catch (...) {
37266       {
37267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37268       };
37269     }
37270   }
37271
37272   jresult = (void *)result;
37273   return jresult;
37274 }
37275
37276
37277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
37278   void * jresult ;
37279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37280   Dali::Actor::OnSceneSignalType *result = 0 ;
37281
37282   arg1 = (Dali::Actor *)jarg1;
37283   {
37284     try {
37285       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
37286     } catch (std::out_of_range& e) {
37287       {
37288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37289       };
37290     } catch (std::exception& e) {
37291       {
37292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37293       };
37294     } catch (Dali::DaliException e) {
37295       {
37296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37297       };
37298     } catch (...) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37301       };
37302     }
37303   }
37304
37305   jresult = (void *)result;
37306   return jresult;
37307 }
37308
37309
37310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
37311   void * jresult ;
37312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37313   Dali::Actor::OffSceneSignalType *result = 0 ;
37314
37315   arg1 = (Dali::Actor *)jarg1;
37316   {
37317     try {
37318       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (Dali::DaliException e) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37330       };
37331     } catch (...) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37334       };
37335     }
37336   }
37337
37338   jresult = (void *)result;
37339   return jresult;
37340 }
37341
37342
37343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37344   void * jresult ;
37345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37346   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37347
37348   arg1 = (Dali::Actor *)jarg1;
37349   {
37350     try {
37351       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37352     } catch (std::out_of_range& e) {
37353       {
37354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37355       };
37356     } catch (std::exception& e) {
37357       {
37358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37359       };
37360     } catch (Dali::DaliException e) {
37361       {
37362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37363       };
37364     } catch (...) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37367       };
37368     }
37369   }
37370
37371   jresult = (void *)result;
37372   return jresult;
37373 }
37374
37375
37376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37377   Dali::Actor *arg1 = 0 ;
37378
37379   arg1 = (Dali::Actor *)jarg1;
37380   if (!arg1) {
37381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37382     return ;
37383   }
37384   {
37385     try {
37386       Dali::UnparentAndReset(*arg1);
37387     } catch (std::out_of_range& e) {
37388       {
37389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37390       };
37391     } catch (std::exception& e) {
37392       {
37393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37394       };
37395     } catch (Dali::DaliException e) {
37396       {
37397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37398       };
37399     } catch (...) {
37400       {
37401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37402       };
37403     }
37404   }
37405
37406 }
37407
37408
37409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37410   int jresult ;
37411   int result;
37412
37413   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37414   jresult = (int)result;
37415   return jresult;
37416 }
37417
37418
37419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37420   int jresult ;
37421   int result;
37422
37423   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37424   jresult = (int)result;
37425   return jresult;
37426 }
37427
37428
37429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37430   int jresult ;
37431   int result;
37432
37433   result = (int)Dali::Layer::Property::BEHAVIOR;
37434   jresult = (int)result;
37435   return jresult;
37436 }
37437
37438
37439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37440   void * jresult ;
37441   Dali::Layer::Property *result = 0 ;
37442
37443   {
37444     try {
37445       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37446     } catch (std::out_of_range& e) {
37447       {
37448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (std::exception& e) {
37451       {
37452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37453       };
37454     } catch (Dali::DaliException e) {
37455       {
37456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37457       };
37458     } catch (...) {
37459       {
37460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37461       };
37462     }
37463   }
37464
37465   jresult = (void *)result;
37466   return jresult;
37467 }
37468
37469
37470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37471   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37472
37473   arg1 = (Dali::Layer::Property *)jarg1;
37474   {
37475     try {
37476       delete arg1;
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37484       };
37485     } catch (Dali::DaliException e) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37488       };
37489     } catch (...) {
37490       {
37491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37492       };
37493     }
37494   }
37495
37496 }
37497
37498
37499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37500   void * jresult ;
37501   Dali::Layer *result = 0 ;
37502
37503   {
37504     try {
37505       result = (Dali::Layer *)new Dali::Layer();
37506     } catch (std::out_of_range& e) {
37507       {
37508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37509       };
37510     } catch (std::exception& e) {
37511       {
37512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37513       };
37514     } catch (Dali::DaliException e) {
37515       {
37516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37517       };
37518     } catch (...) {
37519       {
37520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37521       };
37522     }
37523   }
37524
37525   jresult = (void *)result;
37526   return jresult;
37527 }
37528
37529
37530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37531   void * jresult ;
37532   Dali::Layer result;
37533
37534   {
37535     try {
37536       result = Dali::Layer::New();
37537     } catch (std::out_of_range& e) {
37538       {
37539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37540       };
37541     } catch (std::exception& e) {
37542       {
37543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37544       };
37545     } catch (Dali::DaliException e) {
37546       {
37547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37548       };
37549     } catch (...) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37552       };
37553     }
37554   }
37555
37556   jresult = new Dali::Layer((const Dali::Layer &)result);
37557   return jresult;
37558 }
37559
37560
37561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37562   void * jresult ;
37563   Dali::BaseHandle arg1 ;
37564   Dali::BaseHandle *argp1 ;
37565   Dali::Layer result;
37566
37567   argp1 = (Dali::BaseHandle *)jarg1;
37568   if (!argp1) {
37569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37570     return 0;
37571   }
37572   arg1 = *argp1;
37573   {
37574     try {
37575       result = Dali::Layer::DownCast(arg1);
37576     } catch (std::out_of_range& e) {
37577       {
37578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37579       };
37580     } catch (std::exception& e) {
37581       {
37582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37583       };
37584     } catch (Dali::DaliException e) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37587       };
37588     } catch (...) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37591       };
37592     }
37593   }
37594
37595   jresult = new Dali::Layer((const Dali::Layer &)result);
37596   return jresult;
37597 }
37598
37599
37600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37601   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37602
37603   arg1 = (Dali::Layer *)jarg1;
37604   {
37605     try {
37606       delete arg1;
37607     } catch (std::out_of_range& e) {
37608       {
37609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37610       };
37611     } catch (std::exception& e) {
37612       {
37613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37614       };
37615     } catch (Dali::DaliException e) {
37616       {
37617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37618       };
37619     } catch (...) {
37620       {
37621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37622       };
37623     }
37624   }
37625
37626 }
37627
37628
37629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37630   void * jresult ;
37631   Dali::Layer *arg1 = 0 ;
37632   Dali::Layer *result = 0 ;
37633
37634   arg1 = (Dali::Layer *)jarg1;
37635   if (!arg1) {
37636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37637     return 0;
37638   }
37639   {
37640     try {
37641       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37642     } catch (std::out_of_range& e) {
37643       {
37644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37645       };
37646     } catch (std::exception& e) {
37647       {
37648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37649       };
37650     } catch (Dali::DaliException e) {
37651       {
37652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37653       };
37654     } catch (...) {
37655       {
37656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37657       };
37658     }
37659   }
37660
37661   jresult = (void *)result;
37662   return jresult;
37663 }
37664
37665
37666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37667   void * jresult ;
37668   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37669   Dali::Layer *arg2 = 0 ;
37670   Dali::Layer *result = 0 ;
37671
37672   arg1 = (Dali::Layer *)jarg1;
37673   arg2 = (Dali::Layer *)jarg2;
37674   if (!arg2) {
37675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37676     return 0;
37677   }
37678   {
37679     try {
37680       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37681     } catch (std::out_of_range& e) {
37682       {
37683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37684       };
37685     } catch (std::exception& e) {
37686       {
37687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37688       };
37689     } catch (Dali::DaliException e) {
37690       {
37691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37692       };
37693     } catch (...) {
37694       {
37695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37696       };
37697     }
37698   }
37699
37700   jresult = (void *)result;
37701   return jresult;
37702 }
37703
37704
37705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37706   unsigned int jresult ;
37707   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37708   unsigned int result;
37709
37710   arg1 = (Dali::Layer *)jarg1;
37711   {
37712     try {
37713       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37714     } catch (std::out_of_range& e) {
37715       {
37716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (std::exception& e) {
37719       {
37720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37721       };
37722     } catch (Dali::DaliException e) {
37723       {
37724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37725       };
37726     } catch (...) {
37727       {
37728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37729       };
37730     }
37731   }
37732
37733   jresult = result;
37734   return jresult;
37735 }
37736
37737
37738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37739   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37740
37741   arg1 = (Dali::Layer *)jarg1;
37742   {
37743     try {
37744       (arg1)->Raise();
37745     } catch (std::out_of_range& e) {
37746       {
37747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37748       };
37749     } catch (std::exception& e) {
37750       {
37751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (Dali::DaliException e) {
37754       {
37755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37756       };
37757     } catch (...) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37760       };
37761     }
37762   }
37763
37764 }
37765
37766
37767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37768   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37769
37770   arg1 = (Dali::Layer *)jarg1;
37771   {
37772     try {
37773       (arg1)->Lower();
37774     } catch (std::out_of_range& e) {
37775       {
37776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37777       };
37778     } catch (std::exception& e) {
37779       {
37780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37781       };
37782     } catch (Dali::DaliException e) {
37783       {
37784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37785       };
37786     } catch (...) {
37787       {
37788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37789       };
37790     }
37791   }
37792
37793 }
37794
37795
37796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37797   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37798   Dali::Layer arg2 ;
37799   Dali::Layer *argp2 ;
37800
37801   arg1 = (Dali::Layer *)jarg1;
37802   argp2 = (Dali::Layer *)jarg2;
37803   if (!argp2) {
37804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37805     return ;
37806   }
37807   arg2 = *argp2;
37808   {
37809     try {
37810       (arg1)->RaiseAbove(arg2);
37811     } catch (std::out_of_range& e) {
37812       {
37813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37814       };
37815     } catch (std::exception& e) {
37816       {
37817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37818       };
37819     } catch (Dali::DaliException e) {
37820       {
37821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37822       };
37823     } catch (...) {
37824       {
37825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37826       };
37827     }
37828   }
37829
37830 }
37831
37832
37833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37834   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37835   Dali::Layer arg2 ;
37836   Dali::Layer *argp2 ;
37837
37838   arg1 = (Dali::Layer *)jarg1;
37839   argp2 = (Dali::Layer *)jarg2;
37840   if (!argp2) {
37841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37842     return ;
37843   }
37844   arg2 = *argp2;
37845   {
37846     try {
37847       (arg1)->LowerBelow(arg2);
37848     } catch (std::out_of_range& e) {
37849       {
37850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37851       };
37852     } catch (std::exception& e) {
37853       {
37854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37855       };
37856     } catch (Dali::DaliException e) {
37857       {
37858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37859       };
37860     } catch (...) {
37861       {
37862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37863       };
37864     }
37865   }
37866
37867 }
37868
37869
37870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37872
37873   arg1 = (Dali::Layer *)jarg1;
37874   {
37875     try {
37876       (arg1)->RaiseToTop();
37877     } catch (std::out_of_range& e) {
37878       {
37879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37880       };
37881     } catch (std::exception& e) {
37882       {
37883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37884       };
37885     } catch (Dali::DaliException e) {
37886       {
37887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37888       };
37889     } catch (...) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37892       };
37893     }
37894   }
37895
37896 }
37897
37898
37899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37900   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37901
37902   arg1 = (Dali::Layer *)jarg1;
37903   {
37904     try {
37905       (arg1)->LowerToBottom();
37906     } catch (std::out_of_range& e) {
37907       {
37908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37909       };
37910     } catch (std::exception& e) {
37911       {
37912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37913       };
37914     } catch (Dali::DaliException e) {
37915       {
37916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37917       };
37918     } catch (...) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37921       };
37922     }
37923   }
37924
37925 }
37926
37927
37928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37929   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37930   Dali::Layer arg2 ;
37931   Dali::Layer *argp2 ;
37932
37933   arg1 = (Dali::Layer *)jarg1;
37934   argp2 = (Dali::Layer *)jarg2;
37935   if (!argp2) {
37936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37937     return ;
37938   }
37939   arg2 = *argp2;
37940   {
37941     try {
37942       (arg1)->MoveAbove(arg2);
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 (Dali::DaliException e) {
37952       {
37953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37954       };
37955     } catch (...) {
37956       {
37957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37958       };
37959     }
37960   }
37961
37962 }
37963
37964
37965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37966   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37967   Dali::Layer arg2 ;
37968   Dali::Layer *argp2 ;
37969
37970   arg1 = (Dali::Layer *)jarg1;
37971   argp2 = (Dali::Layer *)jarg2;
37972   if (!argp2) {
37973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37974     return ;
37975   }
37976   arg2 = *argp2;
37977   {
37978     try {
37979       (arg1)->MoveBelow(arg2);
37980     } catch (std::out_of_range& e) {
37981       {
37982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37983       };
37984     } catch (std::exception& e) {
37985       {
37986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37987       };
37988     } catch (Dali::DaliException e) {
37989       {
37990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37991       };
37992     } catch (...) {
37993       {
37994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37995       };
37996     }
37997   }
37998
37999 }
38000
38001
38002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
38003   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38004   Dali::Layer::Behavior arg2 ;
38005
38006   arg1 = (Dali::Layer *)jarg1;
38007   arg2 = (Dali::Layer::Behavior)jarg2;
38008   {
38009     try {
38010       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
38011     } catch (std::out_of_range& e) {
38012       {
38013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38014       };
38015     } catch (std::exception& e) {
38016       {
38017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38018       };
38019     } catch (Dali::DaliException e) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38022       };
38023     } catch (...) {
38024       {
38025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38026       };
38027     }
38028   }
38029
38030 }
38031
38032
38033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
38034   int jresult ;
38035   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38036   Dali::Layer::Behavior result;
38037
38038   arg1 = (Dali::Layer *)jarg1;
38039   {
38040     try {
38041       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (Dali::DaliException e) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38053       };
38054     } catch (...) {
38055       {
38056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38057       };
38058     }
38059   }
38060
38061   jresult = (int)result;
38062   return jresult;
38063 }
38064
38065
38066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
38067   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38068   bool arg2 ;
38069
38070   arg1 = (Dali::Layer *)jarg1;
38071   arg2 = jarg2 ? true : false;
38072   {
38073     try {
38074       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
38075     } catch (std::out_of_range& e) {
38076       {
38077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38078       };
38079     } catch (std::exception& e) {
38080       {
38081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38082       };
38083     } catch (Dali::DaliException e) {
38084       {
38085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38086       };
38087     } catch (...) {
38088       {
38089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38090       };
38091     }
38092   }
38093
38094 }
38095
38096
38097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
38098   unsigned int jresult ;
38099   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38100   bool result;
38101
38102   arg1 = (Dali::Layer *)jarg1;
38103   {
38104     try {
38105       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
38106     } catch (std::out_of_range& e) {
38107       {
38108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38109       };
38110     } catch (std::exception& e) {
38111       {
38112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38113       };
38114     } catch (Dali::DaliException e) {
38115       {
38116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38117       };
38118     } catch (...) {
38119       {
38120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38121       };
38122     }
38123   }
38124
38125   jresult = result;
38126   return jresult;
38127 }
38128
38129
38130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38131   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38132   int arg2 ;
38133   int arg3 ;
38134   int arg4 ;
38135   int arg5 ;
38136
38137   arg1 = (Dali::Layer *)jarg1;
38138   arg2 = (int)jarg2;
38139   arg3 = (int)jarg3;
38140   arg4 = (int)jarg4;
38141   arg5 = (int)jarg5;
38142   {
38143     try {
38144       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
38145     } catch (std::out_of_range& e) {
38146       {
38147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38148       };
38149     } catch (std::exception& e) {
38150       {
38151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38152       };
38153     } catch (Dali::DaliException e) {
38154       {
38155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38156       };
38157     } catch (...) {
38158       {
38159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38160       };
38161     }
38162   }
38163
38164 }
38165
38166
38167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38168   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38169   Dali::ClippingBox arg2 ;
38170   Dali::ClippingBox *argp2 ;
38171
38172   arg1 = (Dali::Layer *)jarg1;
38173   argp2 = (Dali::ClippingBox *)jarg2;
38174   if (!argp2) {
38175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38176     return ;
38177   }
38178   arg2 = *argp2;
38179   {
38180     try {
38181       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
38182     } catch (std::out_of_range& e) {
38183       {
38184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38185       };
38186     } catch (std::exception& e) {
38187       {
38188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38189       };
38190     } catch (Dali::DaliException e) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38193       };
38194     } catch (...) {
38195       {
38196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38197       };
38198     }
38199   }
38200
38201 }
38202
38203
38204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38205   void * jresult ;
38206   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38207   Dali::ClippingBox result;
38208
38209   arg1 = (Dali::Layer *)jarg1;
38210   {
38211     try {
38212       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
38213     } catch (std::out_of_range& e) {
38214       {
38215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38216       };
38217     } catch (std::exception& e) {
38218       {
38219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38220       };
38221     } catch (Dali::DaliException e) {
38222       {
38223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38224       };
38225     } catch (...) {
38226       {
38227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38228       };
38229     }
38230   }
38231
38232   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38233   return jresult;
38234 }
38235
38236
38237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38238   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38239   bool arg2 ;
38240
38241   arg1 = (Dali::Layer *)jarg1;
38242   arg2 = jarg2 ? true : false;
38243   {
38244     try {
38245       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
38246     } catch (std::out_of_range& e) {
38247       {
38248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38249       };
38250     } catch (std::exception& e) {
38251       {
38252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38253       };
38254     } catch (Dali::DaliException e) {
38255       {
38256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38257       };
38258     } catch (...) {
38259       {
38260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38261       };
38262     }
38263   }
38264
38265 }
38266
38267
38268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38269   unsigned int jresult ;
38270   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38271   bool result;
38272
38273   arg1 = (Dali::Layer *)jarg1;
38274   {
38275     try {
38276       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
38277     } catch (std::out_of_range& e) {
38278       {
38279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38280       };
38281     } catch (std::exception& e) {
38282       {
38283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38284       };
38285     } catch (Dali::DaliException e) {
38286       {
38287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38288       };
38289     } catch (...) {
38290       {
38291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38292       };
38293     }
38294   }
38295
38296   jresult = result;
38297   return jresult;
38298 }
38299
38300
38301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38302   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38303   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38304
38305   arg1 = (Dali::Layer *)jarg1;
38306   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38307   {
38308     try {
38309       (arg1)->SetSortFunction(arg2);
38310     } catch (std::out_of_range& e) {
38311       {
38312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38313       };
38314     } catch (std::exception& e) {
38315       {
38316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38317       };
38318     } catch (Dali::DaliException e) {
38319       {
38320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38321       };
38322     } catch (...) {
38323       {
38324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38325       };
38326     }
38327   }
38328
38329 }
38330
38331
38332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38333   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38334   bool arg2 ;
38335
38336   arg1 = (Dali::Layer *)jarg1;
38337   arg2 = jarg2 ? true : false;
38338   {
38339     try {
38340       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38341     } catch (std::out_of_range& e) {
38342       {
38343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38344       };
38345     } catch (std::exception& e) {
38346       {
38347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38348       };
38349     } catch (Dali::DaliException e) {
38350       {
38351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38352       };
38353     } catch (...) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38356       };
38357     }
38358   }
38359
38360 }
38361
38362
38363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38364   unsigned int jresult ;
38365   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38366   bool result;
38367
38368   arg1 = (Dali::Layer *)jarg1;
38369   {
38370     try {
38371       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38372     } catch (std::out_of_range& e) {
38373       {
38374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (std::exception& e) {
38377       {
38378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38379       };
38380     } catch (Dali::DaliException e) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38383       };
38384     } catch (...) {
38385       {
38386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38387       };
38388     }
38389   }
38390
38391   jresult = result;
38392   return jresult;
38393 }
38394
38395
38396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38397   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38398   bool arg2 ;
38399
38400   arg1 = (Dali::Layer *)jarg1;
38401   arg2 = jarg2 ? true : false;
38402   {
38403     try {
38404       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38405     } catch (std::out_of_range& e) {
38406       {
38407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38408       };
38409     } catch (std::exception& e) {
38410       {
38411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38412       };
38413     } catch (Dali::DaliException e) {
38414       {
38415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38416       };
38417     } catch (...) {
38418       {
38419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38420       };
38421     }
38422   }
38423
38424 }
38425
38426
38427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38428   unsigned int jresult ;
38429   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38430   bool result;
38431
38432   arg1 = (Dali::Layer *)jarg1;
38433   {
38434     try {
38435       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38436     } catch (std::out_of_range& e) {
38437       {
38438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (std::exception& e) {
38441       {
38442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38443       };
38444     } catch (Dali::DaliException e) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38447       };
38448     } catch (...) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38451       };
38452     }
38453   }
38454
38455   jresult = result;
38456   return jresult;
38457 }
38458
38459
38460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38461   void * jresult ;
38462   Dali::Stage result;
38463
38464   {
38465     try {
38466       result = Dali::Stage::GetCurrent();
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 (Dali::DaliException e) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38478       };
38479     } catch (...) {
38480       {
38481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38482       };
38483     }
38484   }
38485
38486   jresult = new Dali::Stage((const Dali::Stage &)result);
38487   return jresult;
38488 }
38489
38490
38491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38492   unsigned int jresult ;
38493   bool result;
38494
38495   {
38496     try {
38497       result = (bool)Dali::Stage::IsInstalled();
38498     } catch (std::out_of_range& e) {
38499       {
38500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38501       };
38502     } catch (std::exception& e) {
38503       {
38504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38505       };
38506     } catch (Dali::DaliException e) {
38507       {
38508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38509       };
38510     } catch (...) {
38511       {
38512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38513       };
38514     }
38515   }
38516
38517   jresult = result;
38518   return jresult;
38519 }
38520
38521
38522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38523   void * jresult ;
38524   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38525   Dali::Vector2 result;
38526
38527   arg1 = (Dali::Stage *)jarg1;
38528   {
38529     try {
38530       result = ((Dali::Stage const *)arg1)->GetDpi();
38531     } catch (std::out_of_range& e) {
38532       {
38533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38534       };
38535     } catch (std::exception& e) {
38536       {
38537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38538       };
38539     } catch (Dali::DaliException e) {
38540       {
38541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38542       };
38543     } catch (...) {
38544       {
38545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38546       };
38547     }
38548   }
38549
38550   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38551   return jresult;
38552 }
38553
38554
38555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38556   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38557   float arg2 ;
38558
38559   arg1 = (Dali::Stage *)jarg1;
38560   arg2 = (float)jarg2;
38561   {
38562     try {
38563       (arg1)->KeepRendering(arg2);
38564     } catch (std::out_of_range& e) {
38565       {
38566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38567       };
38568     } catch (std::exception& e) {
38569       {
38570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38571       };
38572     } catch (Dali::DaliException e) {
38573       {
38574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38579       };
38580     }
38581   }
38582
38583 }
38584
38585
38586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38587   void * jresult ;
38588   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38589   Dali::Stage::KeyEventSignalType *result = 0 ;
38590
38591   arg1 = (Dali::Stage *)jarg1;
38592   {
38593     try {
38594       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38595     } catch (std::out_of_range& e) {
38596       {
38597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38598       };
38599     } catch (std::exception& e) {
38600       {
38601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38602       };
38603     } catch (Dali::DaliException e) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38606       };
38607     } catch (...) {
38608       {
38609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38610       };
38611     }
38612   }
38613
38614   jresult = (void *)result;
38615   return jresult;
38616 }
38617
38618
38619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38620   void * jresult ;
38621   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38622   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38623
38624   arg1 = (Dali::Stage *)jarg1;
38625   {
38626     try {
38627       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38628     } catch (std::out_of_range& e) {
38629       {
38630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38631       };
38632     } catch (std::exception& e) {
38633       {
38634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38635       };
38636     } catch (Dali::DaliException e) {
38637       {
38638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38639       };
38640     } catch (...) {
38641       {
38642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38643       };
38644     }
38645   }
38646
38647   jresult = (void *)result;
38648   return jresult;
38649 }
38650
38651
38652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38653   void * jresult ;
38654   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38655   Dali::Stage::TouchSignalType *result = 0 ;
38656
38657   arg1 = (Dali::Stage *)jarg1;
38658   {
38659     try {
38660       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38661     } catch (std::out_of_range& e) {
38662       {
38663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (std::exception& e) {
38666       {
38667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38668       };
38669     } catch (Dali::DaliException e) {
38670       {
38671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38672       };
38673     } catch (...) {
38674       {
38675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38676       };
38677     }
38678   }
38679
38680   jresult = (void *)result;
38681   return jresult;
38682 }
38683
38684
38685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38686   void * jresult ;
38687   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38688   Dali::Stage::WheelEventSignalType *result = 0 ;
38689
38690   arg1 = (Dali::Stage *)jarg1;
38691   {
38692     try {
38693       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38694     } catch (std::out_of_range& e) {
38695       {
38696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38697       };
38698     } catch (std::exception& e) {
38699       {
38700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38701       };
38702     } catch (Dali::DaliException e) {
38703       {
38704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38705       };
38706     } catch (...) {
38707       {
38708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38709       };
38710     }
38711   }
38712
38713   jresult = (void *)result;
38714   return jresult;
38715 }
38716
38717
38718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38719   void * jresult ;
38720   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38721   Dali::Stage::ContextStatusSignal *result = 0 ;
38722
38723   arg1 = (Dali::Stage *)jarg1;
38724   {
38725     try {
38726       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38727     } catch (std::out_of_range& e) {
38728       {
38729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38730       };
38731     } catch (std::exception& e) {
38732       {
38733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38734       };
38735     } catch (Dali::DaliException e) {
38736       {
38737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38738       };
38739     } catch (...) {
38740       {
38741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38742       };
38743     }
38744   }
38745
38746   jresult = (void *)result;
38747   return jresult;
38748 }
38749
38750
38751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38752   void * jresult ;
38753   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38754   Dali::Stage::ContextStatusSignal *result = 0 ;
38755
38756   arg1 = (Dali::Stage *)jarg1;
38757   {
38758     try {
38759       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38760     } catch (std::out_of_range& e) {
38761       {
38762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38763       };
38764     } catch (std::exception& e) {
38765       {
38766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38767       };
38768     } catch (Dali::DaliException e) {
38769       {
38770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38771       };
38772     } catch (...) {
38773       {
38774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38775       };
38776     }
38777   }
38778
38779   jresult = (void *)result;
38780   return jresult;
38781 }
38782
38783
38784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38785   void * jresult ;
38786   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38787   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38788
38789   arg1 = (Dali::Stage *)jarg1;
38790   {
38791     try {
38792       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (Dali::DaliException e) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38804       };
38805     } catch (...) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38808       };
38809     }
38810   }
38811
38812   jresult = (void *)result;
38813   return jresult;
38814 }
38815
38816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38817   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38818   Dali::DevelStage::Rendering arg2 ;
38819
38820   arg1 = (Dali::Stage *)jarg1;
38821   arg2 = (Dali::DevelStage::Rendering)jarg2;
38822   {
38823     try {
38824       DevelStage::SetRenderingBehavior(*arg1,arg2);
38825     } catch (std::out_of_range& e) {
38826       {
38827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38828       };
38829     } catch (std::exception& e) {
38830       {
38831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38832       };
38833     } catch (Dali::DaliException e) {
38834       {
38835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38836       };
38837     } catch (...) {
38838       {
38839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38840       };
38841     }
38842   }
38843
38844 }
38845
38846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38847
38848   int jresult ;
38849   int result ;
38850   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38851
38852   arg1 = (Dali::Stage *)jarg1;
38853   {
38854     try {
38855       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38856     } catch (std::out_of_range& e) {
38857       {
38858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38859       };
38860     } catch (std::exception& e) {
38861       {
38862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38863       };
38864     } catch (Dali::DaliException e) {
38865       {
38866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38867       };
38868     } catch (...) {
38869       {
38870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38871       };
38872     }
38873   }
38874
38875   jresult = result;
38876   return jresult;
38877 }
38878
38879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38880   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38881
38882   arg1 = (Dali::RelayoutContainer *)jarg1;
38883   {
38884     try {
38885       delete arg1;
38886     } catch (std::out_of_range& e) {
38887       {
38888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38889       };
38890     } catch (std::exception& e) {
38891       {
38892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38893       };
38894     } catch (Dali::DaliException e) {
38895       {
38896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38897       };
38898     } catch (...) {
38899       {
38900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38901       };
38902     }
38903   }
38904
38905 }
38906
38907
38908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38909   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38910   Dali::Actor *arg2 = 0 ;
38911   Dali::Vector2 *arg3 = 0 ;
38912
38913   arg1 = (Dali::RelayoutContainer *)jarg1;
38914   arg2 = (Dali::Actor *)jarg2;
38915   if (!arg2) {
38916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38917     return ;
38918   }
38919   arg3 = (Dali::Vector2 *)jarg3;
38920   if (!arg3) {
38921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38922     return ;
38923   }
38924   {
38925     try {
38926       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38927     } catch (std::out_of_range& e) {
38928       {
38929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38930       };
38931     } catch (std::exception& e) {
38932       {
38933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38934       };
38935     } catch (Dali::DaliException e) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38938       };
38939     } catch (...) {
38940       {
38941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38942       };
38943     }
38944   }
38945
38946 }
38947
38948
38949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38950   void * jresult ;
38951   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38952   Dali::CustomActor result;
38953
38954   arg1 = (Dali::CustomActorImpl *)jarg1;
38955   {
38956     try {
38957       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38958     } catch (std::out_of_range& e) {
38959       {
38960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38961       };
38962     } catch (std::exception& e) {
38963       {
38964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38965       };
38966     } catch (Dali::DaliException e) {
38967       {
38968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38969       };
38970     } catch (...) {
38971       {
38972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38973       };
38974     }
38975   }
38976
38977   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38978   return jresult;
38979 }
38980
38981
38982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38984   int arg2 ;
38985
38986   arg1 = (Dali::CustomActorImpl *)jarg1;
38987   arg2 = (int)jarg2;
38988   {
38989     try {
38990       (arg1)->OnSceneConnection(arg2);
38991     } catch (std::out_of_range& e) {
38992       {
38993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38994       };
38995     } catch (std::exception& e) {
38996       {
38997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38998       };
38999     } catch (Dali::DaliException e) {
39000       {
39001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39002       };
39003     } catch (...) {
39004       {
39005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39006       };
39007     }
39008   }
39009
39010 }
39011
39012
39013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
39014   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39015
39016   arg1 = (Dali::CustomActorImpl *)jarg1;
39017   {
39018     try {
39019       (arg1)->OnSceneDisconnection();
39020     } catch (std::out_of_range& e) {
39021       {
39022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39023       };
39024     } catch (std::exception& e) {
39025       {
39026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39027       };
39028     } catch (Dali::DaliException e) {
39029       {
39030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39031       };
39032     } catch (...) {
39033       {
39034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39035       };
39036     }
39037   }
39038
39039 }
39040
39041
39042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39043   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39044   Dali::Actor *arg2 = 0 ;
39045
39046   arg1 = (Dali::CustomActorImpl *)jarg1;
39047   arg2 = (Dali::Actor *)jarg2;
39048   if (!arg2) {
39049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39050     return ;
39051   }
39052   {
39053     try {
39054       (arg1)->OnChildAdd(*arg2);
39055     } catch (std::out_of_range& e) {
39056       {
39057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39058       };
39059     } catch (std::exception& e) {
39060       {
39061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39062       };
39063     } catch (Dali::DaliException e) {
39064       {
39065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39066       };
39067     } catch (...) {
39068       {
39069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39070       };
39071     }
39072   }
39073
39074 }
39075
39076
39077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39078   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39079   Dali::Actor *arg2 = 0 ;
39080
39081   arg1 = (Dali::CustomActorImpl *)jarg1;
39082   arg2 = (Dali::Actor *)jarg2;
39083   if (!arg2) {
39084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39085     return ;
39086   }
39087   {
39088     try {
39089       (arg1)->OnChildRemove(*arg2);
39090     } catch (std::out_of_range& e) {
39091       {
39092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39093       };
39094     } catch (std::exception& e) {
39095       {
39096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39097       };
39098     } catch (Dali::DaliException e) {
39099       {
39100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39101       };
39102     } catch (...) {
39103       {
39104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39105       };
39106     }
39107   }
39108
39109 }
39110
39111
39112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39113   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39114   Dali::Property::Index arg2 ;
39115   Dali::Property::Value arg3 ;
39116   Dali::Property::Value *argp3 ;
39117
39118   arg1 = (Dali::CustomActorImpl *)jarg1;
39119   arg2 = (Dali::Property::Index)jarg2;
39120   argp3 = (Dali::Property::Value *)jarg3;
39121   if (!argp3) {
39122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39123     return ;
39124   }
39125   arg3 = *argp3;
39126   {
39127     try {
39128       (arg1)->OnPropertySet(arg2,arg3);
39129     } catch (std::out_of_range& e) {
39130       {
39131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39132       };
39133     } catch (std::exception& e) {
39134       {
39135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (Dali::DaliException e) {
39138       {
39139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39144       };
39145     }
39146   }
39147
39148 }
39149
39150
39151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39152   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39153   Dali::Vector3 *arg2 = 0 ;
39154
39155   arg1 = (Dali::CustomActorImpl *)jarg1;
39156   arg2 = (Dali::Vector3 *)jarg2;
39157   if (!arg2) {
39158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39159     return ;
39160   }
39161   {
39162     try {
39163       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39164     } catch (std::out_of_range& e) {
39165       {
39166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39167       };
39168     } catch (std::exception& e) {
39169       {
39170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39171       };
39172     } catch (Dali::DaliException e) {
39173       {
39174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39175       };
39176     } catch (...) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39179       };
39180     }
39181   }
39182
39183 }
39184
39185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39186   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39187   Dali::Animation *arg2 = 0 ;
39188   Dali::Vector3 *arg3 = 0 ;
39189
39190   arg1 = (Dali::CustomActorImpl *)jarg1;
39191   arg2 = (Dali::Animation *)jarg2;
39192   if (!arg2) {
39193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39194     return ;
39195   }
39196   arg3 = (Dali::Vector3 *)jarg3;
39197   if (!arg3) {
39198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39199     return ;
39200   }
39201   {
39202     try {
39203       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39204     } catch (std::out_of_range& e) {
39205       {
39206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39207       };
39208     } catch (std::exception& e) {
39209       {
39210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39211       };
39212     } catch (Dali::DaliException e) {
39213       {
39214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39215       };
39216     } catch (...) {
39217       {
39218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39219       };
39220     }
39221   }
39222 }
39223
39224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39225   unsigned int jresult ;
39226   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39227   Dali::HoverEvent *arg2 = 0 ;
39228   bool result;
39229
39230   arg1 = (Dali::CustomActorImpl *)jarg1;
39231   arg2 = (Dali::HoverEvent *)jarg2;
39232   if (!arg2) {
39233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39234     return 0;
39235   }
39236   {
39237     try {
39238       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39239     } catch (std::out_of_range& e) {
39240       {
39241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39242       };
39243     } catch (std::exception& e) {
39244       {
39245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39246       };
39247     } catch (Dali::DaliException e) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39254       };
39255     }
39256   }
39257
39258   jresult = result;
39259   return jresult;
39260 }
39261
39262
39263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39264   unsigned int jresult ;
39265   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39266   Dali::KeyEvent *arg2 = 0 ;
39267   bool result;
39268
39269   arg1 = (Dali::CustomActorImpl *)jarg1;
39270   arg2 = (Dali::KeyEvent *)jarg2;
39271   if (!arg2) {
39272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39273     return 0;
39274   }
39275   {
39276     try {
39277       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39278     } catch (std::out_of_range& e) {
39279       {
39280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39281       };
39282     } catch (std::exception& e) {
39283       {
39284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39285       };
39286     } catch (Dali::DaliException e) {
39287       {
39288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39289       };
39290     } catch (...) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39293       };
39294     }
39295   }
39296
39297   jresult = result;
39298   return jresult;
39299 }
39300
39301
39302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39303   unsigned int jresult ;
39304   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39305   Dali::WheelEvent *arg2 = 0 ;
39306   bool result;
39307
39308   arg1 = (Dali::CustomActorImpl *)jarg1;
39309   arg2 = (Dali::WheelEvent *)jarg2;
39310   if (!arg2) {
39311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39312     return 0;
39313   }
39314   {
39315     try {
39316       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39317     } catch (std::out_of_range& e) {
39318       {
39319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39320       };
39321     } catch (std::exception& e) {
39322       {
39323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39324       };
39325     } catch (Dali::DaliException e) {
39326       {
39327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39328       };
39329     } catch (...) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39332       };
39333     }
39334   }
39335
39336   jresult = result;
39337   return jresult;
39338 }
39339
39340
39341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39342   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39343   Dali::Vector2 *arg2 = 0 ;
39344   Dali::RelayoutContainer *arg3 = 0 ;
39345
39346   arg1 = (Dali::CustomActorImpl *)jarg1;
39347   arg2 = (Dali::Vector2 *)jarg2;
39348   if (!arg2) {
39349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39350     return ;
39351   }
39352   arg3 = (Dali::RelayoutContainer *)jarg3;
39353   if (!arg3) {
39354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39355     return ;
39356   }
39357   {
39358     try {
39359       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39360     } catch (std::out_of_range& e) {
39361       {
39362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39363       };
39364     } catch (std::exception& e) {
39365       {
39366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39367       };
39368     } catch (Dali::DaliException e) {
39369       {
39370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39375       };
39376     }
39377   }
39378
39379 }
39380
39381
39382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39383   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39384   Dali::ResizePolicy::Type arg2 ;
39385   Dali::Dimension::Type arg3 ;
39386
39387   arg1 = (Dali::CustomActorImpl *)jarg1;
39388   arg2 = (Dali::ResizePolicy::Type)jarg2;
39389   arg3 = (Dali::Dimension::Type)jarg3;
39390   {
39391     try {
39392       (arg1)->OnSetResizePolicy(arg2,arg3);
39393     } catch (std::out_of_range& e) {
39394       {
39395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39396       };
39397     } catch (std::exception& e) {
39398       {
39399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39400       };
39401     } catch (Dali::DaliException e) {
39402       {
39403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39404       };
39405     } catch (...) {
39406       {
39407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39408       };
39409     }
39410   }
39411
39412 }
39413
39414
39415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39416   void * jresult ;
39417   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39418   Dali::Vector3 result;
39419
39420   arg1 = (Dali::CustomActorImpl *)jarg1;
39421   {
39422     try {
39423       result = (arg1)->GetNaturalSize();
39424     } catch (std::out_of_range& e) {
39425       {
39426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39427       };
39428     } catch (std::exception& e) {
39429       {
39430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39431       };
39432     } catch (Dali::DaliException e) {
39433       {
39434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39435       };
39436     } catch (...) {
39437       {
39438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39439       };
39440     }
39441   }
39442
39443   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39444   return jresult;
39445 }
39446
39447
39448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39449   float jresult ;
39450   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39451   Dali::Actor *arg2 = 0 ;
39452   Dali::Dimension::Type arg3 ;
39453   float result;
39454
39455   arg1 = (Dali::CustomActorImpl *)jarg1;
39456   arg2 = (Dali::Actor *)jarg2;
39457   if (!arg2) {
39458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39459     return 0;
39460   }
39461   arg3 = (Dali::Dimension::Type)jarg3;
39462   {
39463     try {
39464       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39465     } catch (std::out_of_range& e) {
39466       {
39467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39468       };
39469     } catch (std::exception& e) {
39470       {
39471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39472       };
39473     } catch (Dali::DaliException e) {
39474       {
39475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39476       };
39477     } catch (...) {
39478       {
39479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39480       };
39481     }
39482   }
39483
39484   jresult = result;
39485   return jresult;
39486 }
39487
39488
39489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39490   float jresult ;
39491   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39492   float arg2 ;
39493   float result;
39494
39495   arg1 = (Dali::CustomActorImpl *)jarg1;
39496   arg2 = (float)jarg2;
39497   {
39498     try {
39499       result = (float)(arg1)->GetHeightForWidth(arg2);
39500     } catch (std::out_of_range& e) {
39501       {
39502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39503       };
39504     } catch (std::exception& e) {
39505       {
39506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39507       };
39508     } catch (Dali::DaliException e) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39511       };
39512     } catch (...) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39515       };
39516     }
39517   }
39518
39519   jresult = result;
39520   return jresult;
39521 }
39522
39523
39524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39525   float jresult ;
39526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39527   float arg2 ;
39528   float result;
39529
39530   arg1 = (Dali::CustomActorImpl *)jarg1;
39531   arg2 = (float)jarg2;
39532   {
39533     try {
39534       result = (float)(arg1)->GetWidthForHeight(arg2);
39535     } catch (std::out_of_range& e) {
39536       {
39537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (std::exception& e) {
39540       {
39541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (Dali::DaliException e) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39546       };
39547     } catch (...) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39550       };
39551     }
39552   }
39553
39554   jresult = result;
39555   return jresult;
39556 }
39557
39558
39559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39560   unsigned int jresult ;
39561   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39562   Dali::Dimension::Type arg2 ;
39563   bool result;
39564
39565   arg1 = (Dali::CustomActorImpl *)jarg1;
39566   arg2 = (Dali::Dimension::Type)jarg2;
39567   {
39568     try {
39569       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39570     } catch (std::out_of_range& e) {
39571       {
39572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39573       };
39574     } catch (std::exception& e) {
39575       {
39576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39577       };
39578     } catch (Dali::DaliException e) {
39579       {
39580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39581       };
39582     } catch (...) {
39583       {
39584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39585       };
39586     }
39587   }
39588
39589   jresult = result;
39590   return jresult;
39591 }
39592
39593
39594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39595   unsigned int jresult ;
39596   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39597   bool result;
39598
39599   arg1 = (Dali::CustomActorImpl *)jarg1;
39600   {
39601     try {
39602       result = (bool)(arg1)->RelayoutDependentOnChildren();
39603     } catch (std::out_of_range& e) {
39604       {
39605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39606       };
39607     } catch (std::exception& e) {
39608       {
39609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39610       };
39611     } catch (Dali::DaliException e) {
39612       {
39613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39614       };
39615     } catch (...) {
39616       {
39617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39618       };
39619     }
39620   }
39621
39622   jresult = result;
39623   return jresult;
39624 }
39625
39626
39627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39628   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39629   Dali::Dimension::Type arg2 ;
39630
39631   arg1 = (Dali::CustomActorImpl *)jarg1;
39632   arg2 = (Dali::Dimension::Type)jarg2;
39633   {
39634     try {
39635       (arg1)->OnCalculateRelayoutSize(arg2);
39636     } catch (std::out_of_range& e) {
39637       {
39638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39639       };
39640     } catch (std::exception& e) {
39641       {
39642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39643       };
39644     } catch (Dali::DaliException e) {
39645       {
39646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39647       };
39648     } catch (...) {
39649       {
39650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39651       };
39652     }
39653   }
39654
39655 }
39656
39657
39658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39659   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39660   float arg2 ;
39661   Dali::Dimension::Type arg3 ;
39662
39663   arg1 = (Dali::CustomActorImpl *)jarg1;
39664   arg2 = (float)jarg2;
39665   arg3 = (Dali::Dimension::Type)jarg3;
39666   {
39667     try {
39668       (arg1)->OnLayoutNegotiated(arg2,arg3);
39669     } catch (std::out_of_range& e) {
39670       {
39671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39672       };
39673     } catch (std::exception& e) {
39674       {
39675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39676       };
39677     } catch (Dali::DaliException e) {
39678       {
39679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39680       };
39681     } catch (...) {
39682       {
39683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39684       };
39685     }
39686   }
39687
39688 }
39689
39690
39691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39692   unsigned int jresult ;
39693   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39694   bool result;
39695
39696   arg1 = (Dali::CustomActorImpl *)jarg1;
39697   {
39698     try {
39699       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39707       };
39708     } catch (Dali::DaliException e) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39715       };
39716     }
39717   }
39718
39719   jresult = result;
39720   return jresult;
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39725   unsigned int jresult ;
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   bool result;
39728
39729   arg1 = (Dali::CustomActorImpl *)jarg1;
39730   {
39731     try {
39732       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39733     } catch (std::out_of_range& e) {
39734       {
39735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39736       };
39737     } catch (std::exception& e) {
39738       {
39739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (Dali::DaliException e) {
39742       {
39743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39744       };
39745     } catch (...) {
39746       {
39747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39748       };
39749     }
39750   }
39751
39752   jresult = result;
39753   return jresult;
39754 }
39755
39756
39757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39758   unsigned int jresult ;
39759   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39760   bool result;
39761
39762   arg1 = (Dali::CustomActorImpl *)jarg1;
39763   {
39764     try {
39765       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39766     } catch (std::out_of_range& e) {
39767       {
39768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39769       };
39770     } catch (std::exception& e) {
39771       {
39772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39773       };
39774     } catch (Dali::DaliException e) {
39775       {
39776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39781       };
39782     }
39783   }
39784
39785   jresult = result;
39786   return jresult;
39787 }
39788
39789
39790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39791   unsigned int jresult ;
39792   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39793   bool result;
39794
39795   arg1 = (Dali::CustomActorImpl *)jarg1;
39796   {
39797     try {
39798       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39799     } catch (std::out_of_range& e) {
39800       {
39801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39802       };
39803     } catch (std::exception& e) {
39804       {
39805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39806       };
39807     } catch (Dali::DaliException e) {
39808       {
39809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39810       };
39811     } catch (...) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39814       };
39815     }
39816   }
39817
39818   jresult = result;
39819   return jresult;
39820 }
39821
39822
39823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39824   void * jresult ;
39825   Dali::CustomActor *result = 0 ;
39826
39827   {
39828     try {
39829       result = (Dali::CustomActor *)new Dali::CustomActor();
39830     } catch (std::out_of_range& e) {
39831       {
39832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (std::exception& e) {
39835       {
39836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39837       };
39838     } catch (Dali::DaliException e) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39841       };
39842     } catch (...) {
39843       {
39844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39845       };
39846     }
39847   }
39848
39849   jresult = (void *)result;
39850   return jresult;
39851 }
39852
39853
39854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39855   void * jresult ;
39856   Dali::BaseHandle arg1 ;
39857   Dali::BaseHandle *argp1 ;
39858   Dali::CustomActor result;
39859
39860   argp1 = (Dali::BaseHandle *)jarg1;
39861   if (!argp1) {
39862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39863     return 0;
39864   }
39865   arg1 = *argp1;
39866   {
39867     try {
39868       result = Dali::CustomActor::DownCast(arg1);
39869     } catch (std::out_of_range& e) {
39870       {
39871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39872       };
39873     } catch (std::exception& e) {
39874       {
39875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39876       };
39877     } catch (Dali::DaliException e) {
39878       {
39879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39880       };
39881     } catch (...) {
39882       {
39883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39884       };
39885     }
39886   }
39887
39888   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39889   return jresult;
39890 }
39891
39892
39893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39894   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39895
39896   arg1 = (Dali::CustomActor *)jarg1;
39897   {
39898     try {
39899       delete arg1;
39900     } catch (std::out_of_range& e) {
39901       {
39902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39903       };
39904     } catch (std::exception& e) {
39905       {
39906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39907       };
39908     } catch (Dali::DaliException e) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39911       };
39912     } catch (...) {
39913       {
39914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39915       };
39916     }
39917   }
39918
39919 }
39920
39921
39922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39923   void * jresult ;
39924   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39925   Dali::CustomActorImpl *result = 0 ;
39926
39927   arg1 = (Dali::CustomActor *)jarg1;
39928   {
39929     try {
39930       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39931     } catch (std::out_of_range& e) {
39932       {
39933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39934       };
39935     } catch (std::exception& e) {
39936       {
39937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39938       };
39939     } catch (Dali::DaliException e) {
39940       {
39941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39942       };
39943     } catch (...) {
39944       {
39945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39946       };
39947     }
39948   }
39949
39950   jresult = (void *)result;
39951   return jresult;
39952 }
39953
39954
39955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39956   void * jresult ;
39957   Dali::CustomActorImpl *arg1 = 0 ;
39958   Dali::CustomActor *result = 0 ;
39959
39960   arg1 = (Dali::CustomActorImpl *)jarg1;
39961   if (!arg1) {
39962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39963     return 0;
39964   }
39965   {
39966     try {
39967       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39968     } catch (std::out_of_range& e) {
39969       {
39970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39971       };
39972     } catch (std::exception& e) {
39973       {
39974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39975       };
39976     } catch (Dali::DaliException e) {
39977       {
39978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39979       };
39980     } catch (...) {
39981       {
39982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39983       };
39984     }
39985   }
39986
39987   jresult = (void *)result;
39988   return jresult;
39989 }
39990
39991
39992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39993   void * jresult ;
39994   Dali::CustomActor *arg1 = 0 ;
39995   Dali::CustomActor *result = 0 ;
39996
39997   arg1 = (Dali::CustomActor *)jarg1;
39998   if (!arg1) {
39999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40000     return 0;
40001   }
40002   {
40003     try {
40004       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40005     } catch (std::out_of_range& e) {
40006       {
40007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40008       };
40009     } catch (std::exception& e) {
40010       {
40011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40012       };
40013     } catch (Dali::DaliException e) {
40014       {
40015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40016       };
40017     } catch (...) {
40018       {
40019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40020       };
40021     }
40022   }
40023
40024   jresult = (void *)result;
40025   return jresult;
40026 }
40027
40028
40029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40030   void * jresult ;
40031   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40032   Dali::CustomActor *arg2 = 0 ;
40033   Dali::CustomActor *result = 0 ;
40034
40035   arg1 = (Dali::CustomActor *)jarg1;
40036   arg2 = (Dali::CustomActor *)jarg2;
40037   if (!arg2) {
40038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40039     return 0;
40040   }
40041   {
40042     try {
40043       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40044     } catch (std::out_of_range& e) {
40045       {
40046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40047       };
40048     } catch (std::exception& e) {
40049       {
40050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40051       };
40052     } catch (Dali::DaliException e) {
40053       {
40054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40055       };
40056     } catch (...) {
40057       {
40058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40059       };
40060     }
40061   }
40062
40063   jresult = (void *)result;
40064   return jresult;
40065 }
40066
40067
40068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40069   int jresult ;
40070   int result;
40071
40072   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40073   jresult = (int)result;
40074   return jresult;
40075 }
40076
40077
40078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40079   int jresult ;
40080   int result;
40081
40082   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40083   jresult = (int)result;
40084   return jresult;
40085 }
40086
40087
40088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40089   int jresult ;
40090   int result;
40091
40092   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40093   jresult = (int)result;
40094   return jresult;
40095 }
40096
40097
40098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40099   int jresult ;
40100   int result;
40101
40102   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40103   jresult = (int)result;
40104   return jresult;
40105 }
40106
40107
40108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40109   int jresult ;
40110   int result;
40111
40112   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40113   jresult = (int)result;
40114   return jresult;
40115 }
40116
40117
40118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40119   int jresult ;
40120   int result;
40121
40122   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40123   jresult = (int)result;
40124   return jresult;
40125 }
40126
40127
40128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40129   int jresult ;
40130   int result;
40131
40132   result = (int)Dali::PanGestureDetector::Property::PANNING;
40133   jresult = (int)result;
40134   return jresult;
40135 }
40136
40137
40138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40139   void * jresult ;
40140   Dali::PanGestureDetector::Property *result = 0 ;
40141
40142   {
40143     try {
40144       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40145     } catch (std::out_of_range& e) {
40146       {
40147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40148       };
40149     } catch (std::exception& e) {
40150       {
40151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40152       };
40153     } catch (Dali::DaliException e) {
40154       {
40155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40156       };
40157     } catch (...) {
40158       {
40159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40160       };
40161     }
40162   }
40163
40164   jresult = (void *)result;
40165   return jresult;
40166 }
40167
40168
40169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40170   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40171
40172   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40173   {
40174     try {
40175       delete arg1;
40176     } catch (std::out_of_range& e) {
40177       {
40178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40179       };
40180     } catch (std::exception& e) {
40181       {
40182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40183       };
40184     } catch (Dali::DaliException e) {
40185       {
40186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40187       };
40188     } catch (...) {
40189       {
40190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40191       };
40192     }
40193   }
40194
40195 }
40196
40197
40198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40199   void * jresult ;
40200   Dali::Radian *result = 0 ;
40201
40202   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40203   jresult = (void *)result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40209   void * jresult ;
40210   Dali::Radian *result = 0 ;
40211
40212   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40213   jresult = (void *)result;
40214   return jresult;
40215 }
40216
40217
40218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40219   void * jresult ;
40220   Dali::Radian *result = 0 ;
40221
40222   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40223   jresult = (void *)result;
40224   return jresult;
40225 }
40226
40227
40228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40229   void * jresult ;
40230   Dali::Radian *result = 0 ;
40231
40232   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40233   jresult = (void *)result;
40234   return jresult;
40235 }
40236
40237
40238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40239   void * jresult ;
40240   Dali::Radian *result = 0 ;
40241
40242   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40243   jresult = (void *)result;
40244   return jresult;
40245 }
40246
40247
40248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40249   void * jresult ;
40250   Dali::Radian *result = 0 ;
40251
40252   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40253   jresult = (void *)result;
40254   return jresult;
40255 }
40256
40257
40258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40259   void * jresult ;
40260   Dali::Radian *result = 0 ;
40261
40262   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40263   jresult = (void *)result;
40264   return jresult;
40265 }
40266
40267
40268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40269   void * jresult ;
40270   Dali::PanGestureDetector *result = 0 ;
40271
40272   {
40273     try {
40274       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40275     } catch (std::out_of_range& e) {
40276       {
40277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40278       };
40279     } catch (std::exception& e) {
40280       {
40281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40282       };
40283     } catch (Dali::DaliException e) {
40284       {
40285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40286       };
40287     } catch (...) {
40288       {
40289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40290       };
40291     }
40292   }
40293
40294   jresult = (void *)result;
40295   return jresult;
40296 }
40297
40298
40299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40300   void * jresult ;
40301   Dali::PanGestureDetector result;
40302
40303   {
40304     try {
40305       result = Dali::PanGestureDetector::New();
40306     } catch (std::out_of_range& e) {
40307       {
40308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40309       };
40310     } catch (std::exception& e) {
40311       {
40312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40313       };
40314     } catch (Dali::DaliException e) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40317       };
40318     } catch (...) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40321       };
40322     }
40323   }
40324
40325   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40326   return jresult;
40327 }
40328
40329
40330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40331   void * jresult ;
40332   Dali::BaseHandle arg1 ;
40333   Dali::BaseHandle *argp1 ;
40334   Dali::PanGestureDetector result;
40335
40336   argp1 = (Dali::BaseHandle *)jarg1;
40337   if (!argp1) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40339     return 0;
40340   }
40341   arg1 = *argp1;
40342   {
40343     try {
40344       result = Dali::PanGestureDetector::DownCast(arg1);
40345     } catch (std::out_of_range& e) {
40346       {
40347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40348       };
40349     } catch (std::exception& e) {
40350       {
40351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40352       };
40353     } catch (Dali::DaliException e) {
40354       {
40355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40356       };
40357     } catch (...) {
40358       {
40359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40360       };
40361     }
40362   }
40363
40364   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40365   return jresult;
40366 }
40367
40368
40369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40370   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40371
40372   arg1 = (Dali::PanGestureDetector *)jarg1;
40373   {
40374     try {
40375       delete arg1;
40376     } catch (std::out_of_range& e) {
40377       {
40378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40379       };
40380     } catch (std::exception& e) {
40381       {
40382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40383       };
40384     } catch (Dali::DaliException e) {
40385       {
40386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40387       };
40388     } catch (...) {
40389       {
40390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40391       };
40392     }
40393   }
40394
40395 }
40396
40397
40398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40399   void * jresult ;
40400   Dali::PanGestureDetector *arg1 = 0 ;
40401   Dali::PanGestureDetector *result = 0 ;
40402
40403   arg1 = (Dali::PanGestureDetector *)jarg1;
40404   if (!arg1) {
40405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40406     return 0;
40407   }
40408   {
40409     try {
40410       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40411     } catch (std::out_of_range& e) {
40412       {
40413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40414       };
40415     } catch (std::exception& e) {
40416       {
40417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40418       };
40419     } catch (Dali::DaliException e) {
40420       {
40421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40422       };
40423     } catch (...) {
40424       {
40425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40426       };
40427     }
40428   }
40429
40430   jresult = (void *)result;
40431   return jresult;
40432 }
40433
40434
40435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40436   void * jresult ;
40437   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40438   Dali::PanGestureDetector *arg2 = 0 ;
40439   Dali::PanGestureDetector *result = 0 ;
40440
40441   arg1 = (Dali::PanGestureDetector *)jarg1;
40442   arg2 = (Dali::PanGestureDetector *)jarg2;
40443   if (!arg2) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40445     return 0;
40446   }
40447   {
40448     try {
40449       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40450     } catch (std::out_of_range& e) {
40451       {
40452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40453       };
40454     } catch (std::exception& e) {
40455       {
40456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40457       };
40458     } catch (Dali::DaliException e) {
40459       {
40460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40461       };
40462     } catch (...) {
40463       {
40464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40465       };
40466     }
40467   }
40468
40469   jresult = (void *)result;
40470   return jresult;
40471 }
40472
40473
40474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40475   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40476   unsigned int arg2 ;
40477
40478   arg1 = (Dali::PanGestureDetector *)jarg1;
40479   arg2 = (unsigned int)jarg2;
40480   {
40481     try {
40482       (arg1)->SetMinimumTouchesRequired(arg2);
40483     } catch (std::out_of_range& e) {
40484       {
40485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40486       };
40487     } catch (std::exception& e) {
40488       {
40489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40490       };
40491     } catch (Dali::DaliException e) {
40492       {
40493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40494       };
40495     } catch (...) {
40496       {
40497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40498       };
40499     }
40500   }
40501
40502 }
40503
40504
40505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40506   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40507   unsigned int arg2 ;
40508
40509   arg1 = (Dali::PanGestureDetector *)jarg1;
40510   arg2 = (unsigned int)jarg2;
40511   {
40512     try {
40513       (arg1)->SetMaximumTouchesRequired(arg2);
40514     } catch (std::out_of_range& e) {
40515       {
40516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40517       };
40518     } catch (std::exception& e) {
40519       {
40520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40521       };
40522     } catch (Dali::DaliException e) {
40523       {
40524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40525       };
40526     } catch (...) {
40527       {
40528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40529       };
40530     }
40531   }
40532
40533 }
40534
40535
40536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40537   unsigned int jresult ;
40538   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40539   unsigned int result;
40540
40541   arg1 = (Dali::PanGestureDetector *)jarg1;
40542   {
40543     try {
40544       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40545     } catch (std::out_of_range& e) {
40546       {
40547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40548       };
40549     } catch (std::exception& e) {
40550       {
40551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40552       };
40553     } catch (Dali::DaliException e) {
40554       {
40555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40556       };
40557     } catch (...) {
40558       {
40559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40560       };
40561     }
40562   }
40563
40564   jresult = result;
40565   return jresult;
40566 }
40567
40568
40569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40570   unsigned int jresult ;
40571   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40572   unsigned int result;
40573
40574   arg1 = (Dali::PanGestureDetector *)jarg1;
40575   {
40576     try {
40577       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40578     } catch (std::out_of_range& e) {
40579       {
40580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40581       };
40582     } catch (std::exception& e) {
40583       {
40584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40585       };
40586     } catch (Dali::DaliException e) {
40587       {
40588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40589       };
40590     } catch (...) {
40591       {
40592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40593       };
40594     }
40595   }
40596
40597   jresult = result;
40598   return jresult;
40599 }
40600
40601
40602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40603   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40604   Dali::Radian arg2 ;
40605   Dali::Radian arg3 ;
40606   Dali::Radian *argp2 ;
40607   Dali::Radian *argp3 ;
40608
40609   arg1 = (Dali::PanGestureDetector *)jarg1;
40610   argp2 = (Dali::Radian *)jarg2;
40611   if (!argp2) {
40612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40613     return ;
40614   }
40615   arg2 = *argp2;
40616   argp3 = (Dali::Radian *)jarg3;
40617   if (!argp3) {
40618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40619     return ;
40620   }
40621   arg3 = *argp3;
40622   {
40623     try {
40624       (arg1)->AddAngle(arg2,arg3);
40625     } catch (std::out_of_range& e) {
40626       {
40627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40628       };
40629     } catch (std::exception& e) {
40630       {
40631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40632       };
40633     } catch (Dali::DaliException e) {
40634       {
40635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40636       };
40637     } catch (...) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40640       };
40641     }
40642   }
40643
40644 }
40645
40646
40647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40648   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40649   Dali::Radian arg2 ;
40650   Dali::Radian *argp2 ;
40651
40652   arg1 = (Dali::PanGestureDetector *)jarg1;
40653   argp2 = (Dali::Radian *)jarg2;
40654   if (!argp2) {
40655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40656     return ;
40657   }
40658   arg2 = *argp2;
40659   {
40660     try {
40661       (arg1)->AddAngle(arg2);
40662     } catch (std::out_of_range& e) {
40663       {
40664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40665       };
40666     } catch (std::exception& e) {
40667       {
40668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40669       };
40670     } catch (Dali::DaliException e) {
40671       {
40672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40673       };
40674     } catch (...) {
40675       {
40676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40677       };
40678     }
40679   }
40680
40681 }
40682
40683
40684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40685   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40686   Dali::Radian arg2 ;
40687   Dali::Radian arg3 ;
40688   Dali::Radian *argp2 ;
40689   Dali::Radian *argp3 ;
40690
40691   arg1 = (Dali::PanGestureDetector *)jarg1;
40692   argp2 = (Dali::Radian *)jarg2;
40693   if (!argp2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40695     return ;
40696   }
40697   arg2 = *argp2;
40698   argp3 = (Dali::Radian *)jarg3;
40699   if (!argp3) {
40700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40701     return ;
40702   }
40703   arg3 = *argp3;
40704   {
40705     try {
40706       (arg1)->AddDirection(arg2,arg3);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40722       };
40723     }
40724   }
40725
40726 }
40727
40728
40729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40730   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40731   Dali::Radian arg2 ;
40732   Dali::Radian *argp2 ;
40733
40734   arg1 = (Dali::PanGestureDetector *)jarg1;
40735   argp2 = (Dali::Radian *)jarg2;
40736   if (!argp2) {
40737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40738     return ;
40739   }
40740   arg2 = *argp2;
40741   {
40742     try {
40743       (arg1)->AddDirection(arg2);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40759       };
40760     }
40761   }
40762
40763 }
40764
40765
40766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40767   unsigned long jresult ;
40768   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40769   size_t result;
40770
40771   arg1 = (Dali::PanGestureDetector *)jarg1;
40772   {
40773     try {
40774       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40775     } catch (std::out_of_range& e) {
40776       {
40777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40778       };
40779     } catch (std::exception& e) {
40780       {
40781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40782       };
40783     } catch (Dali::DaliException e) {
40784       {
40785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40786       };
40787     } catch (...) {
40788       {
40789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40790       };
40791     }
40792   }
40793
40794   jresult = (unsigned long)result;
40795   return jresult;
40796 }
40797
40798
40799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40800   void * jresult ;
40801   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40802   size_t arg2 ;
40803   Dali::PanGestureDetector::AngleThresholdPair result;
40804
40805   arg1 = (Dali::PanGestureDetector *)jarg1;
40806   arg2 = (size_t)jarg2;
40807   {
40808     try {
40809       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40810     } catch (std::out_of_range& e) {
40811       {
40812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40813       };
40814     } catch (std::exception& e) {
40815       {
40816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40817       };
40818     } catch (Dali::DaliException e) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40821       };
40822     } catch (...) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40825       };
40826     }
40827   }
40828
40829   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40830   return jresult;
40831 }
40832
40833
40834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40835   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40836
40837   arg1 = (Dali::PanGestureDetector *)jarg1;
40838   {
40839     try {
40840       (arg1)->ClearAngles();
40841     } catch (std::out_of_range& e) {
40842       {
40843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40844       };
40845     } catch (std::exception& e) {
40846       {
40847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40848       };
40849     } catch (Dali::DaliException e) {
40850       {
40851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40852       };
40853     } catch (...) {
40854       {
40855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40856       };
40857     }
40858   }
40859
40860 }
40861
40862
40863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40864   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40865   Dali::Radian arg2 ;
40866   Dali::Radian *argp2 ;
40867
40868   arg1 = (Dali::PanGestureDetector *)jarg1;
40869   argp2 = (Dali::Radian *)jarg2;
40870   if (!argp2) {
40871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40872     return ;
40873   }
40874   arg2 = *argp2;
40875   {
40876     try {
40877       (arg1)->RemoveAngle(arg2);
40878     } catch (std::out_of_range& e) {
40879       {
40880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40881       };
40882     } catch (std::exception& e) {
40883       {
40884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40885       };
40886     } catch (Dali::DaliException e) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40889       };
40890     } catch (...) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40893       };
40894     }
40895   }
40896
40897 }
40898
40899
40900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40901   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40902   Dali::Radian arg2 ;
40903   Dali::Radian *argp2 ;
40904
40905   arg1 = (Dali::PanGestureDetector *)jarg1;
40906   argp2 = (Dali::Radian *)jarg2;
40907   if (!argp2) {
40908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40909     return ;
40910   }
40911   arg2 = *argp2;
40912   {
40913     try {
40914       (arg1)->RemoveDirection(arg2);
40915     } catch (std::out_of_range& e) {
40916       {
40917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40918       };
40919     } catch (std::exception& e) {
40920       {
40921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40922       };
40923     } catch (Dali::DaliException e) {
40924       {
40925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40926       };
40927     } catch (...) {
40928       {
40929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40930       };
40931     }
40932   }
40933
40934 }
40935
40936
40937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40938   void * jresult ;
40939   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40940   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40941
40942   arg1 = (Dali::PanGestureDetector *)jarg1;
40943   {
40944     try {
40945       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40946     } catch (std::out_of_range& e) {
40947       {
40948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40949       };
40950     } catch (std::exception& e) {
40951       {
40952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40953       };
40954     } catch (Dali::DaliException e) {
40955       {
40956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40957       };
40958     } catch (...) {
40959       {
40960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40961       };
40962     }
40963   }
40964
40965   jresult = (void *)result;
40966   return jresult;
40967 }
40968
40969
40970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40971   Dali::PanGesture *arg1 = 0 ;
40972
40973   arg1 = (Dali::PanGesture *)jarg1;
40974   if (!arg1) {
40975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40976     return ;
40977   }
40978   {
40979     try {
40980       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40981     } catch (std::out_of_range& e) {
40982       {
40983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40984       };
40985     } catch (std::exception& e) {
40986       {
40987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40988       };
40989     } catch (Dali::DaliException e) {
40990       {
40991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40992       };
40993     } catch (...) {
40994       {
40995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40996       };
40997     }
40998   }
40999
41000 }
41001
41002
41003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41004   void * jresult ;
41005   Dali::PanGesture *result = 0 ;
41006
41007   {
41008     try {
41009       result = (Dali::PanGesture *)new Dali::PanGesture();
41010     } catch (std::out_of_range& e) {
41011       {
41012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41013       };
41014     } catch (std::exception& e) {
41015       {
41016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41017       };
41018     } catch (Dali::DaliException e) {
41019       {
41020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41021       };
41022     } catch (...) {
41023       {
41024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41025       };
41026     }
41027   }
41028
41029   jresult = (void *)result;
41030   return jresult;
41031 }
41032
41033
41034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41035   void * jresult ;
41036   Dali::Gesture::State arg1 ;
41037   Dali::PanGesture *result = 0 ;
41038
41039   arg1 = (Dali::Gesture::State)jarg1;
41040   {
41041     try {
41042       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41043     } catch (std::out_of_range& e) {
41044       {
41045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41046       };
41047     } catch (std::exception& e) {
41048       {
41049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41050       };
41051     } catch (Dali::DaliException e) {
41052       {
41053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41054       };
41055     } catch (...) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41058       };
41059     }
41060   }
41061
41062   jresult = (void *)result;
41063   return jresult;
41064 }
41065
41066
41067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41068   void * jresult ;
41069   Dali::PanGesture *arg1 = 0 ;
41070   Dali::PanGesture *result = 0 ;
41071
41072   arg1 = (Dali::PanGesture *)jarg1;
41073   if (!arg1) {
41074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41075     return 0;
41076   }
41077   {
41078     try {
41079       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41080     } catch (std::out_of_range& e) {
41081       {
41082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41083       };
41084     } catch (std::exception& e) {
41085       {
41086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41087       };
41088     } catch (Dali::DaliException e) {
41089       {
41090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41091       };
41092     } catch (...) {
41093       {
41094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41095       };
41096     }
41097   }
41098
41099   jresult = (void *)result;
41100   return jresult;
41101 }
41102
41103
41104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41105   void * jresult ;
41106   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41107   Dali::PanGesture *arg2 = 0 ;
41108   Dali::PanGesture *result = 0 ;
41109
41110   arg1 = (Dali::PanGesture *)jarg1;
41111   arg2 = (Dali::PanGesture *)jarg2;
41112   if (!arg2) {
41113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41114     return 0;
41115   }
41116   {
41117     try {
41118       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41119     } catch (std::out_of_range& e) {
41120       {
41121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41122       };
41123     } catch (std::exception& e) {
41124       {
41125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41126       };
41127     } catch (Dali::DaliException e) {
41128       {
41129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41130       };
41131     } catch (...) {
41132       {
41133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41134       };
41135     }
41136   }
41137
41138   jresult = (void *)result;
41139   return jresult;
41140 }
41141
41142
41143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41144   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41145
41146   arg1 = (Dali::PanGesture *)jarg1;
41147   {
41148     try {
41149       delete arg1;
41150     } catch (std::out_of_range& e) {
41151       {
41152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41153       };
41154     } catch (std::exception& e) {
41155       {
41156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41157       };
41158     } catch (Dali::DaliException e) {
41159       {
41160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41161       };
41162     } catch (...) {
41163       {
41164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41165       };
41166     }
41167   }
41168
41169 }
41170
41171
41172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41173   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41174   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41175
41176   arg1 = (Dali::PanGesture *)jarg1;
41177   arg2 = (Dali::Vector2 *)jarg2;
41178   if (arg1) (arg1)->velocity = *arg2;
41179 }
41180
41181
41182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41183   void * jresult ;
41184   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41185   Dali::Vector2 *result = 0 ;
41186
41187   arg1 = (Dali::PanGesture *)jarg1;
41188   result = (Dali::Vector2 *)& ((arg1)->velocity);
41189   jresult = (void *)result;
41190   return jresult;
41191 }
41192
41193
41194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41197
41198   arg1 = (Dali::PanGesture *)jarg1;
41199   arg2 = (Dali::Vector2 *)jarg2;
41200   if (arg1) (arg1)->displacement = *arg2;
41201 }
41202
41203
41204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41205   void * jresult ;
41206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41207   Dali::Vector2 *result = 0 ;
41208
41209   arg1 = (Dali::PanGesture *)jarg1;
41210   result = (Dali::Vector2 *)& ((arg1)->displacement);
41211   jresult = (void *)result;
41212   return jresult;
41213 }
41214
41215
41216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41219
41220   arg1 = (Dali::PanGesture *)jarg1;
41221   arg2 = (Dali::Vector2 *)jarg2;
41222   if (arg1) (arg1)->position = *arg2;
41223 }
41224
41225
41226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41227   void * jresult ;
41228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41229   Dali::Vector2 *result = 0 ;
41230
41231   arg1 = (Dali::PanGesture *)jarg1;
41232   result = (Dali::Vector2 *)& ((arg1)->position);
41233   jresult = (void *)result;
41234   return jresult;
41235 }
41236
41237
41238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41240   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41241
41242   arg1 = (Dali::PanGesture *)jarg1;
41243   arg2 = (Dali::Vector2 *)jarg2;
41244   if (arg1) (arg1)->screenVelocity = *arg2;
41245 }
41246
41247
41248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41249   void * jresult ;
41250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41251   Dali::Vector2 *result = 0 ;
41252
41253   arg1 = (Dali::PanGesture *)jarg1;
41254   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41255   jresult = (void *)result;
41256   return jresult;
41257 }
41258
41259
41260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41262   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41263
41264   arg1 = (Dali::PanGesture *)jarg1;
41265   arg2 = (Dali::Vector2 *)jarg2;
41266   if (arg1) (arg1)->screenDisplacement = *arg2;
41267 }
41268
41269
41270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41271   void * jresult ;
41272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41273   Dali::Vector2 *result = 0 ;
41274
41275   arg1 = (Dali::PanGesture *)jarg1;
41276   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41277   jresult = (void *)result;
41278   return jresult;
41279 }
41280
41281
41282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41284   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41285
41286   arg1 = (Dali::PanGesture *)jarg1;
41287   arg2 = (Dali::Vector2 *)jarg2;
41288   if (arg1) (arg1)->screenPosition = *arg2;
41289 }
41290
41291
41292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41293   void * jresult ;
41294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41295   Dali::Vector2 *result = 0 ;
41296
41297   arg1 = (Dali::PanGesture *)jarg1;
41298   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41299   jresult = (void *)result;
41300   return jresult;
41301 }
41302
41303
41304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41306   unsigned int arg2 ;
41307
41308   arg1 = (Dali::PanGesture *)jarg1;
41309   arg2 = (unsigned int)jarg2;
41310   if (arg1) (arg1)->numberOfTouches = arg2;
41311 }
41312
41313
41314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41315   unsigned int jresult ;
41316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41317   unsigned int result;
41318
41319   arg1 = (Dali::PanGesture *)jarg1;
41320   result = (unsigned int) ((arg1)->numberOfTouches);
41321   jresult = result;
41322   return jresult;
41323 }
41324
41325
41326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41327   float jresult ;
41328   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41329   float result;
41330
41331   arg1 = (Dali::PanGesture *)jarg1;
41332   {
41333     try {
41334       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41335     } catch (std::out_of_range& e) {
41336       {
41337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41338       };
41339     } catch (std::exception& e) {
41340       {
41341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (Dali::DaliException e) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41346       };
41347     } catch (...) {
41348       {
41349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41350       };
41351     }
41352   }
41353
41354   jresult = result;
41355   return jresult;
41356 }
41357
41358
41359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41360   float jresult ;
41361   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41362   float result;
41363
41364   arg1 = (Dali::PanGesture *)jarg1;
41365   {
41366     try {
41367       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41368     } catch (std::out_of_range& e) {
41369       {
41370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41371       };
41372     } catch (std::exception& e) {
41373       {
41374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (Dali::DaliException e) {
41377       {
41378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41379       };
41380     } catch (...) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41383       };
41384     }
41385   }
41386
41387   jresult = result;
41388   return jresult;
41389 }
41390
41391
41392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41393   float jresult ;
41394   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41395   float result;
41396
41397   arg1 = (Dali::PanGesture *)jarg1;
41398   {
41399     try {
41400       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41401     } catch (std::out_of_range& e) {
41402       {
41403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41404       };
41405     } catch (std::exception& e) {
41406       {
41407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41408       };
41409     } catch (Dali::DaliException e) {
41410       {
41411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41412       };
41413     } catch (...) {
41414       {
41415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41416       };
41417     }
41418   }
41419
41420   jresult = result;
41421   return jresult;
41422 }
41423
41424
41425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41426   float jresult ;
41427   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41428   float result;
41429
41430   arg1 = (Dali::PanGesture *)jarg1;
41431   {
41432     try {
41433       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41434     } catch (std::out_of_range& e) {
41435       {
41436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41437       };
41438     } catch (std::exception& e) {
41439       {
41440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41441       };
41442     } catch (Dali::DaliException e) {
41443       {
41444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41445       };
41446     } catch (...) {
41447       {
41448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41449       };
41450     }
41451   }
41452
41453   jresult = result;
41454   return jresult;
41455 }
41456
41457
41458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41459   void * jresult ;
41460   Dali::PinchGestureDetector *result = 0 ;
41461
41462   {
41463     try {
41464       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41465     } catch (std::out_of_range& e) {
41466       {
41467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (std::exception& e) {
41470       {
41471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41472       };
41473     } catch (Dali::DaliException e) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41476       };
41477     } catch (...) {
41478       {
41479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41480       };
41481     }
41482   }
41483
41484   jresult = (void *)result;
41485   return jresult;
41486 }
41487
41488
41489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41490   void * jresult ;
41491   Dali::PinchGestureDetector result;
41492
41493   {
41494     try {
41495       result = Dali::PinchGestureDetector::New();
41496     } catch (std::out_of_range& e) {
41497       {
41498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41499       };
41500     } catch (std::exception& e) {
41501       {
41502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (Dali::DaliException e) {
41505       {
41506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41507       };
41508     } catch (...) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41511       };
41512     }
41513   }
41514
41515   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41521   void * jresult ;
41522   Dali::BaseHandle arg1 ;
41523   Dali::BaseHandle *argp1 ;
41524   Dali::PinchGestureDetector result;
41525
41526   argp1 = (Dali::BaseHandle *)jarg1;
41527   if (!argp1) {
41528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41529     return 0;
41530   }
41531   arg1 = *argp1;
41532   {
41533     try {
41534       result = Dali::PinchGestureDetector::DownCast(arg1);
41535     } catch (std::out_of_range& e) {
41536       {
41537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41538       };
41539     } catch (std::exception& e) {
41540       {
41541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41542       };
41543     } catch (Dali::DaliException e) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41546       };
41547     } catch (...) {
41548       {
41549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41550       };
41551     }
41552   }
41553
41554   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41555   return jresult;
41556 }
41557
41558
41559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41560   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41561
41562   arg1 = (Dali::PinchGestureDetector *)jarg1;
41563   {
41564     try {
41565       delete arg1;
41566     } catch (std::out_of_range& e) {
41567       {
41568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41569       };
41570     } catch (std::exception& e) {
41571       {
41572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41573       };
41574     } catch (Dali::DaliException e) {
41575       {
41576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41577       };
41578     } catch (...) {
41579       {
41580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41581       };
41582     }
41583   }
41584
41585 }
41586
41587
41588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41589   void * jresult ;
41590   Dali::PinchGestureDetector *arg1 = 0 ;
41591   Dali::PinchGestureDetector *result = 0 ;
41592
41593   arg1 = (Dali::PinchGestureDetector *)jarg1;
41594   if (!arg1) {
41595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41596     return 0;
41597   }
41598   {
41599     try {
41600       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41601     } catch (std::out_of_range& e) {
41602       {
41603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41604       };
41605     } catch (std::exception& e) {
41606       {
41607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (Dali::DaliException e) {
41610       {
41611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41612       };
41613     } catch (...) {
41614       {
41615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41616       };
41617     }
41618   }
41619
41620   jresult = (void *)result;
41621   return jresult;
41622 }
41623
41624
41625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41626   void * jresult ;
41627   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41628   Dali::PinchGestureDetector *arg2 = 0 ;
41629   Dali::PinchGestureDetector *result = 0 ;
41630
41631   arg1 = (Dali::PinchGestureDetector *)jarg1;
41632   arg2 = (Dali::PinchGestureDetector *)jarg2;
41633   if (!arg2) {
41634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41635     return 0;
41636   }
41637   {
41638     try {
41639       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41640     } catch (std::out_of_range& e) {
41641       {
41642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41643       };
41644     } catch (std::exception& e) {
41645       {
41646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41647       };
41648     } catch (Dali::DaliException e) {
41649       {
41650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41651       };
41652     } catch (...) {
41653       {
41654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41655       };
41656     }
41657   }
41658
41659   jresult = (void *)result;
41660   return jresult;
41661 }
41662
41663
41664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41665   void * jresult ;
41666   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41667   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41668
41669   arg1 = (Dali::PinchGestureDetector *)jarg1;
41670   {
41671     try {
41672       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41673     } catch (std::out_of_range& e) {
41674       {
41675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (std::exception& e) {
41678       {
41679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41680       };
41681     } catch (Dali::DaliException e) {
41682       {
41683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41684       };
41685     } catch (...) {
41686       {
41687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41688       };
41689     }
41690   }
41691
41692   jresult = (void *)result;
41693   return jresult;
41694 }
41695
41696
41697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41698   void * jresult ;
41699   Dali::Gesture::State arg1 ;
41700   Dali::PinchGesture *result = 0 ;
41701
41702   arg1 = (Dali::Gesture::State)jarg1;
41703   {
41704     try {
41705       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41706     } catch (std::out_of_range& e) {
41707       {
41708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41709       };
41710     } catch (std::exception& e) {
41711       {
41712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41713       };
41714     } catch (Dali::DaliException e) {
41715       {
41716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41717       };
41718     } catch (...) {
41719       {
41720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41721       };
41722     }
41723   }
41724
41725   jresult = (void *)result;
41726   return jresult;
41727 }
41728
41729
41730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41731   void * jresult ;
41732   Dali::PinchGesture *arg1 = 0 ;
41733   Dali::PinchGesture *result = 0 ;
41734
41735   arg1 = (Dali::PinchGesture *)jarg1;
41736   if (!arg1) {
41737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41738     return 0;
41739   }
41740   {
41741     try {
41742       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41743     } catch (std::out_of_range& e) {
41744       {
41745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41746       };
41747     } catch (std::exception& e) {
41748       {
41749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41750       };
41751     } catch (Dali::DaliException e) {
41752       {
41753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41754       };
41755     } catch (...) {
41756       {
41757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41758       };
41759     }
41760   }
41761
41762   jresult = (void *)result;
41763   return jresult;
41764 }
41765
41766
41767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41768   void * jresult ;
41769   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41770   Dali::PinchGesture *arg2 = 0 ;
41771   Dali::PinchGesture *result = 0 ;
41772
41773   arg1 = (Dali::PinchGesture *)jarg1;
41774   arg2 = (Dali::PinchGesture *)jarg2;
41775   if (!arg2) {
41776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41777     return 0;
41778   }
41779   {
41780     try {
41781       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41782     } catch (std::out_of_range& e) {
41783       {
41784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41785       };
41786     } catch (std::exception& e) {
41787       {
41788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (Dali::DaliException e) {
41791       {
41792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41793       };
41794     } catch (...) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41797       };
41798     }
41799   }
41800
41801   jresult = (void *)result;
41802   return jresult;
41803 }
41804
41805
41806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41807   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41808
41809   arg1 = (Dali::PinchGesture *)jarg1;
41810   {
41811     try {
41812       delete arg1;
41813     } catch (std::out_of_range& e) {
41814       {
41815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41816       };
41817     } catch (std::exception& e) {
41818       {
41819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41820       };
41821     } catch (Dali::DaliException e) {
41822       {
41823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41824       };
41825     } catch (...) {
41826       {
41827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41828       };
41829     }
41830   }
41831
41832 }
41833
41834
41835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41836   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41837   float arg2 ;
41838
41839   arg1 = (Dali::PinchGesture *)jarg1;
41840   arg2 = (float)jarg2;
41841   if (arg1) (arg1)->scale = arg2;
41842 }
41843
41844
41845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41846   float jresult ;
41847   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41848   float result;
41849
41850   arg1 = (Dali::PinchGesture *)jarg1;
41851   result = (float) ((arg1)->scale);
41852   jresult = result;
41853   return jresult;
41854 }
41855
41856
41857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41858   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41859   float arg2 ;
41860
41861   arg1 = (Dali::PinchGesture *)jarg1;
41862   arg2 = (float)jarg2;
41863   if (arg1) (arg1)->speed = arg2;
41864 }
41865
41866
41867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41868   float jresult ;
41869   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41870   float result;
41871
41872   arg1 = (Dali::PinchGesture *)jarg1;
41873   result = (float) ((arg1)->speed);
41874   jresult = result;
41875   return jresult;
41876 }
41877
41878
41879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41880   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41881   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41882
41883   arg1 = (Dali::PinchGesture *)jarg1;
41884   arg2 = (Dali::Vector2 *)jarg2;
41885   if (arg1) (arg1)->screenCenterPoint = *arg2;
41886 }
41887
41888
41889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41890   void * jresult ;
41891   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41892   Dali::Vector2 *result = 0 ;
41893
41894   arg1 = (Dali::PinchGesture *)jarg1;
41895   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41896   jresult = (void *)result;
41897   return jresult;
41898 }
41899
41900
41901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41902   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41903   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41904
41905   arg1 = (Dali::PinchGesture *)jarg1;
41906   arg2 = (Dali::Vector2 *)jarg2;
41907   if (arg1) (arg1)->localCenterPoint = *arg2;
41908 }
41909
41910
41911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41912   void * jresult ;
41913   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41914   Dali::Vector2 *result = 0 ;
41915
41916   arg1 = (Dali::PinchGesture *)jarg1;
41917   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41918   jresult = (void *)result;
41919   return jresult;
41920 }
41921
41922
41923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41924   void * jresult ;
41925   Dali::TapGestureDetector *result = 0 ;
41926
41927   {
41928     try {
41929       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (Dali::DaliException e) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41941       };
41942     } catch (...) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41945       };
41946     }
41947   }
41948
41949   jresult = (void *)result;
41950   return jresult;
41951 }
41952
41953
41954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41955   void * jresult ;
41956   Dali::TapGestureDetector result;
41957
41958   {
41959     try {
41960       result = Dali::TapGestureDetector::New();
41961     } catch (std::out_of_range& e) {
41962       {
41963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (std::exception& e) {
41966       {
41967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41968       };
41969     } catch (Dali::DaliException e) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41972       };
41973     } catch (...) {
41974       {
41975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41976       };
41977     }
41978   }
41979
41980   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41981   return jresult;
41982 }
41983
41984
41985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41986   void * jresult ;
41987   unsigned int arg1 ;
41988   Dali::TapGestureDetector result;
41989
41990   arg1 = (unsigned int)jarg1;
41991   {
41992     try {
41993       result = Dali::TapGestureDetector::New(arg1);
41994     } catch (std::out_of_range& e) {
41995       {
41996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41997       };
41998     } catch (std::exception& e) {
41999       {
42000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42001       };
42002     } catch (Dali::DaliException e) {
42003       {
42004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42005       };
42006     } catch (...) {
42007       {
42008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42009       };
42010     }
42011   }
42012
42013   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42019   void * jresult ;
42020   Dali::BaseHandle arg1 ;
42021   Dali::BaseHandle *argp1 ;
42022   Dali::TapGestureDetector result;
42023
42024   argp1 = (Dali::BaseHandle *)jarg1;
42025   if (!argp1) {
42026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42027     return 0;
42028   }
42029   arg1 = *argp1;
42030   {
42031     try {
42032       result = Dali::TapGestureDetector::DownCast(arg1);
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42040       };
42041     } catch (Dali::DaliException e) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42044       };
42045     } catch (...) {
42046       {
42047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42048       };
42049     }
42050   }
42051
42052   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42053   return jresult;
42054 }
42055
42056
42057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42058   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42059
42060   arg1 = (Dali::TapGestureDetector *)jarg1;
42061   {
42062     try {
42063       delete arg1;
42064     } catch (std::out_of_range& e) {
42065       {
42066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42067       };
42068     } catch (std::exception& e) {
42069       {
42070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42071       };
42072     } catch (Dali::DaliException e) {
42073       {
42074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42075       };
42076     } catch (...) {
42077       {
42078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42079       };
42080     }
42081   }
42082
42083 }
42084
42085
42086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42087   void * jresult ;
42088   Dali::TapGestureDetector *arg1 = 0 ;
42089   Dali::TapGestureDetector *result = 0 ;
42090
42091   arg1 = (Dali::TapGestureDetector *)jarg1;
42092   if (!arg1) {
42093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42094     return 0;
42095   }
42096   {
42097     try {
42098       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42099     } catch (std::out_of_range& e) {
42100       {
42101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42102       };
42103     } catch (std::exception& e) {
42104       {
42105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42106       };
42107     } catch (Dali::DaliException e) {
42108       {
42109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42110       };
42111     } catch (...) {
42112       {
42113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42114       };
42115     }
42116   }
42117
42118   jresult = (void *)result;
42119   return jresult;
42120 }
42121
42122
42123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42124   void * jresult ;
42125   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42126   Dali::TapGestureDetector *arg2 = 0 ;
42127   Dali::TapGestureDetector *result = 0 ;
42128
42129   arg1 = (Dali::TapGestureDetector *)jarg1;
42130   arg2 = (Dali::TapGestureDetector *)jarg2;
42131   if (!arg2) {
42132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42133     return 0;
42134   }
42135   {
42136     try {
42137       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42138     } catch (std::out_of_range& e) {
42139       {
42140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42141       };
42142     } catch (std::exception& e) {
42143       {
42144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42145       };
42146     } catch (Dali::DaliException e) {
42147       {
42148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42149       };
42150     } catch (...) {
42151       {
42152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42153       };
42154     }
42155   }
42156
42157   jresult = (void *)result;
42158   return jresult;
42159 }
42160
42161
42162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42163   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42164   unsigned int arg2 ;
42165
42166   arg1 = (Dali::TapGestureDetector *)jarg1;
42167   arg2 = (unsigned int)jarg2;
42168   {
42169     try {
42170       (arg1)->SetMinimumTapsRequired(arg2);
42171     } catch (std::out_of_range& e) {
42172       {
42173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42174       };
42175     } catch (std::exception& e) {
42176       {
42177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42178       };
42179     } catch (Dali::DaliException e) {
42180       {
42181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42182       };
42183     } catch (...) {
42184       {
42185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42186       };
42187     }
42188   }
42189
42190 }
42191
42192
42193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42194   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42195   unsigned int arg2 ;
42196
42197   arg1 = (Dali::TapGestureDetector *)jarg1;
42198   arg2 = (unsigned int)jarg2;
42199   {
42200     try {
42201       (arg1)->SetMaximumTapsRequired(arg2);
42202     } catch (std::out_of_range& e) {
42203       {
42204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42205       };
42206     } catch (std::exception& e) {
42207       {
42208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42209       };
42210     } catch (Dali::DaliException e) {
42211       {
42212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42213       };
42214     } catch (...) {
42215       {
42216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42217       };
42218     }
42219   }
42220
42221 }
42222
42223
42224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42225   unsigned int jresult ;
42226   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42227   unsigned int result;
42228
42229   arg1 = (Dali::TapGestureDetector *)jarg1;
42230   {
42231     try {
42232       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
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 (Dali::DaliException e) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42244       };
42245     } catch (...) {
42246       {
42247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42248       };
42249     }
42250   }
42251
42252   jresult = result;
42253   return jresult;
42254 }
42255
42256
42257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42258   unsigned int jresult ;
42259   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42260   unsigned int result;
42261
42262   arg1 = (Dali::TapGestureDetector *)jarg1;
42263   {
42264     try {
42265       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42266     } catch (std::out_of_range& e) {
42267       {
42268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42269       };
42270     } catch (std::exception& e) {
42271       {
42272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42273       };
42274     } catch (Dali::DaliException e) {
42275       {
42276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42277       };
42278     } catch (...) {
42279       {
42280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42281       };
42282     }
42283   }
42284
42285   jresult = result;
42286   return jresult;
42287 }
42288
42289
42290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42291   void * jresult ;
42292   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42293   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42294
42295   arg1 = (Dali::TapGestureDetector *)jarg1;
42296   {
42297     try {
42298       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42299     } catch (std::out_of_range& e) {
42300       {
42301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42302       };
42303     } catch (std::exception& e) {
42304       {
42305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42306       };
42307     } catch (Dali::DaliException e) {
42308       {
42309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42310       };
42311     } catch (...) {
42312       {
42313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42314       };
42315     }
42316   }
42317
42318   jresult = (void *)result;
42319   return jresult;
42320 }
42321
42322
42323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42324   void * jresult ;
42325   Dali::TapGesture *result = 0 ;
42326
42327   {
42328     try {
42329       result = (Dali::TapGesture *)new Dali::TapGesture();
42330     } catch (std::out_of_range& e) {
42331       {
42332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42333       };
42334     } catch (std::exception& e) {
42335       {
42336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42337       };
42338     } catch (Dali::DaliException e) {
42339       {
42340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42341       };
42342     } catch (...) {
42343       {
42344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42345       };
42346     }
42347   }
42348
42349   jresult = (void *)result;
42350   return jresult;
42351 }
42352
42353
42354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42355   void * jresult ;
42356   Dali::TapGesture *arg1 = 0 ;
42357   Dali::TapGesture *result = 0 ;
42358
42359   arg1 = (Dali::TapGesture *)jarg1;
42360   if (!arg1) {
42361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42362     return 0;
42363   }
42364   {
42365     try {
42366       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42367     } catch (std::out_of_range& e) {
42368       {
42369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42370       };
42371     } catch (std::exception& e) {
42372       {
42373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42374       };
42375     } catch (Dali::DaliException e) {
42376       {
42377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42378       };
42379     } catch (...) {
42380       {
42381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42382       };
42383     }
42384   }
42385
42386   jresult = (void *)result;
42387   return jresult;
42388 }
42389
42390
42391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42392   void * jresult ;
42393   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42394   Dali::TapGesture *arg2 = 0 ;
42395   Dali::TapGesture *result = 0 ;
42396
42397   arg1 = (Dali::TapGesture *)jarg1;
42398   arg2 = (Dali::TapGesture *)jarg2;
42399   if (!arg2) {
42400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42401     return 0;
42402   }
42403   {
42404     try {
42405       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42406     } catch (std::out_of_range& e) {
42407       {
42408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42409       };
42410     } catch (std::exception& e) {
42411       {
42412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (Dali::DaliException e) {
42415       {
42416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42417       };
42418     } catch (...) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42421       };
42422     }
42423   }
42424
42425   jresult = (void *)result;
42426   return jresult;
42427 }
42428
42429
42430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42431   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42432
42433   arg1 = (Dali::TapGesture *)jarg1;
42434   {
42435     try {
42436       delete arg1;
42437     } catch (std::out_of_range& e) {
42438       {
42439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42440       };
42441     } catch (std::exception& e) {
42442       {
42443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42444       };
42445     } catch (Dali::DaliException e) {
42446       {
42447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42448       };
42449     } catch (...) {
42450       {
42451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42452       };
42453     }
42454   }
42455
42456 }
42457
42458
42459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42460   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42461   unsigned int arg2 ;
42462
42463   arg1 = (Dali::TapGesture *)jarg1;
42464   arg2 = (unsigned int)jarg2;
42465   if (arg1) (arg1)->numberOfTaps = arg2;
42466 }
42467
42468
42469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42470   unsigned int jresult ;
42471   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42472   unsigned int result;
42473
42474   arg1 = (Dali::TapGesture *)jarg1;
42475   result = (unsigned int) ((arg1)->numberOfTaps);
42476   jresult = result;
42477   return jresult;
42478 }
42479
42480
42481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42482   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42483   unsigned int arg2 ;
42484
42485   arg1 = (Dali::TapGesture *)jarg1;
42486   arg2 = (unsigned int)jarg2;
42487   if (arg1) (arg1)->numberOfTouches = arg2;
42488 }
42489
42490
42491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42492   unsigned int jresult ;
42493   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42494   unsigned int result;
42495
42496   arg1 = (Dali::TapGesture *)jarg1;
42497   result = (unsigned int) ((arg1)->numberOfTouches);
42498   jresult = result;
42499   return jresult;
42500 }
42501
42502
42503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42504   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42505   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42506
42507   arg1 = (Dali::TapGesture *)jarg1;
42508   arg2 = (Dali::Vector2 *)jarg2;
42509   if (arg1) (arg1)->screenPoint = *arg2;
42510 }
42511
42512
42513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42514   void * jresult ;
42515   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42516   Dali::Vector2 *result = 0 ;
42517
42518   arg1 = (Dali::TapGesture *)jarg1;
42519   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42520   jresult = (void *)result;
42521   return jresult;
42522 }
42523
42524
42525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42526   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42527   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42528
42529   arg1 = (Dali::TapGesture *)jarg1;
42530   arg2 = (Dali::Vector2 *)jarg2;
42531   if (arg1) (arg1)->localPoint = *arg2;
42532 }
42533
42534
42535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42536   void * jresult ;
42537   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42538   Dali::Vector2 *result = 0 ;
42539
42540   arg1 = (Dali::TapGesture *)jarg1;
42541   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42542   jresult = (void *)result;
42543   return jresult;
42544 }
42545
42546
42547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42548   void * jresult ;
42549   Dali::AlphaFunction *result = 0 ;
42550
42551   {
42552     try {
42553       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42554     } catch (std::out_of_range& e) {
42555       {
42556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42557       };
42558     } catch (std::exception& e) {
42559       {
42560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (Dali::DaliException e) {
42563       {
42564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42565       };
42566     } catch (...) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42569       };
42570     }
42571   }
42572
42573   jresult = (void *)result;
42574   return jresult;
42575 }
42576
42577
42578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42579   void * jresult ;
42580   Dali::AlphaFunction::BuiltinFunction arg1 ;
42581   Dali::AlphaFunction *result = 0 ;
42582
42583   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42584   {
42585     try {
42586       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42587     } catch (std::out_of_range& e) {
42588       {
42589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (std::exception& e) {
42592       {
42593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (Dali::DaliException e) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42602       };
42603     }
42604   }
42605
42606   jresult = (void *)result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42612   void * jresult ;
42613   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42614   Dali::AlphaFunction *result = 0 ;
42615
42616   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42617   {
42618     try {
42619       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (Dali::DaliException e) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42635       };
42636     }
42637   }
42638
42639   jresult = (void *)result;
42640   return jresult;
42641 }
42642
42643
42644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42645   void * jresult ;
42646   Dali::Vector2 *arg1 = 0 ;
42647   Dali::Vector2 *arg2 = 0 ;
42648   Dali::AlphaFunction *result = 0 ;
42649
42650   arg1 = (Dali::Vector2 *)jarg1;
42651   if (!arg1) {
42652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42653     return 0;
42654   }
42655   arg2 = (Dali::Vector2 *)jarg2;
42656   if (!arg2) {
42657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42658     return 0;
42659   }
42660   {
42661     try {
42662       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42663     } catch (std::out_of_range& e) {
42664       {
42665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (std::exception& e) {
42668       {
42669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (Dali::DaliException e) {
42672       {
42673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42674       };
42675     } catch (...) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42678       };
42679     }
42680   }
42681
42682   jresult = (void *)result;
42683   return jresult;
42684 }
42685
42686
42687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42688   void * jresult ;
42689   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42690   Dali::Vector4 result;
42691
42692   arg1 = (Dali::AlphaFunction *)jarg1;
42693   {
42694     try {
42695       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42696     } catch (std::out_of_range& e) {
42697       {
42698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42699       };
42700     } catch (std::exception& e) {
42701       {
42702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42703       };
42704     } catch (Dali::DaliException e) {
42705       {
42706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42707       };
42708     } catch (...) {
42709       {
42710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42711       };
42712     }
42713   }
42714
42715   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42716   return jresult;
42717 }
42718
42719
42720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42721   void * jresult ;
42722   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42723   Dali::AlphaFunctionPrototype result;
42724
42725   arg1 = (Dali::AlphaFunction *)jarg1;
42726   {
42727     try {
42728       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42729     } catch (std::out_of_range& e) {
42730       {
42731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42732       };
42733     } catch (std::exception& e) {
42734       {
42735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42736       };
42737     } catch (Dali::DaliException e) {
42738       {
42739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42740       };
42741     } catch (...) {
42742       {
42743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42744       };
42745     }
42746   }
42747
42748   jresult = (void *)result;
42749   return jresult;
42750 }
42751
42752
42753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42754   int jresult ;
42755   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42756   Dali::AlphaFunction::BuiltinFunction result;
42757
42758   arg1 = (Dali::AlphaFunction *)jarg1;
42759   {
42760     try {
42761       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42762     } catch (std::out_of_range& e) {
42763       {
42764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42765       };
42766     } catch (std::exception& e) {
42767       {
42768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42769       };
42770     } catch (Dali::DaliException e) {
42771       {
42772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42773       };
42774     } catch (...) {
42775       {
42776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42777       };
42778     }
42779   }
42780
42781   jresult = (int)result;
42782   return jresult;
42783 }
42784
42785
42786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42787   int jresult ;
42788   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42789   Dali::AlphaFunction::Mode result;
42790
42791   arg1 = (Dali::AlphaFunction *)jarg1;
42792   {
42793     try {
42794       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42795     } catch (std::out_of_range& e) {
42796       {
42797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (std::exception& e) {
42800       {
42801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42802       };
42803     } catch (Dali::DaliException e) {
42804       {
42805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42806       };
42807     } catch (...) {
42808       {
42809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42810       };
42811     }
42812   }
42813
42814   jresult = (int)result;
42815   return jresult;
42816 }
42817
42818
42819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42820   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42821
42822   arg1 = (Dali::AlphaFunction *)jarg1;
42823   {
42824     try {
42825       delete arg1;
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42833       };
42834     } catch (Dali::DaliException e) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42837       };
42838     } catch (...) {
42839       {
42840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42841       };
42842     }
42843   }
42844
42845 }
42846
42847
42848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42849   void * jresult ;
42850   Dali::KeyFrames result;
42851
42852   {
42853     try {
42854       result = Dali::KeyFrames::New();
42855     } catch (std::out_of_range& e) {
42856       {
42857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42858       };
42859     } catch (std::exception& e) {
42860       {
42861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42862       };
42863     } catch (Dali::DaliException e) {
42864       {
42865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42866       };
42867     } catch (...) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42870       };
42871     }
42872   }
42873
42874   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42875   return jresult;
42876 }
42877
42878
42879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42880   void * jresult ;
42881   Dali::BaseHandle arg1 ;
42882   Dali::BaseHandle *argp1 ;
42883   Dali::KeyFrames result;
42884
42885   argp1 = (Dali::BaseHandle *)jarg1;
42886   if (!argp1) {
42887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42888     return 0;
42889   }
42890   arg1 = *argp1;
42891   {
42892     try {
42893       result = Dali::KeyFrames::DownCast(arg1);
42894     } catch (std::out_of_range& e) {
42895       {
42896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42897       };
42898     } catch (std::exception& e) {
42899       {
42900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42901       };
42902     } catch (Dali::DaliException e) {
42903       {
42904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42905       };
42906     } catch (...) {
42907       {
42908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42909       };
42910     }
42911   }
42912
42913   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42914   return jresult;
42915 }
42916
42917
42918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42919   void * jresult ;
42920   Dali::KeyFrames *result = 0 ;
42921
42922   {
42923     try {
42924       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42925     } catch (std::out_of_range& e) {
42926       {
42927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42928       };
42929     } catch (std::exception& e) {
42930       {
42931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42932       };
42933     } catch (Dali::DaliException e) {
42934       {
42935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42936       };
42937     } catch (...) {
42938       {
42939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42940       };
42941     }
42942   }
42943
42944   jresult = (void *)result;
42945   return jresult;
42946 }
42947
42948
42949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42950   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42951
42952   arg1 = (Dali::KeyFrames *)jarg1;
42953   {
42954     try {
42955       delete arg1;
42956     } catch (std::out_of_range& e) {
42957       {
42958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42959       };
42960     } catch (std::exception& e) {
42961       {
42962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42963       };
42964     } catch (Dali::DaliException e) {
42965       {
42966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42967       };
42968     } catch (...) {
42969       {
42970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42971       };
42972     }
42973   }
42974
42975 }
42976
42977
42978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42979   void * jresult ;
42980   Dali::KeyFrames *arg1 = 0 ;
42981   Dali::KeyFrames *result = 0 ;
42982
42983   arg1 = (Dali::KeyFrames *)jarg1;
42984   if (!arg1) {
42985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42986     return 0;
42987   }
42988   {
42989     try {
42990       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42991     } catch (std::out_of_range& e) {
42992       {
42993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42994       };
42995     } catch (std::exception& e) {
42996       {
42997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42998       };
42999     } catch (Dali::DaliException e) {
43000       {
43001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43002       };
43003     } catch (...) {
43004       {
43005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43006       };
43007     }
43008   }
43009
43010   jresult = (void *)result;
43011   return jresult;
43012 }
43013
43014
43015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43016   void * jresult ;
43017   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43018   Dali::KeyFrames *arg2 = 0 ;
43019   Dali::KeyFrames *result = 0 ;
43020
43021   arg1 = (Dali::KeyFrames *)jarg1;
43022   arg2 = (Dali::KeyFrames *)jarg2;
43023   if (!arg2) {
43024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43025     return 0;
43026   }
43027   {
43028     try {
43029       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43037       };
43038     } catch (Dali::DaliException e) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43041       };
43042     } catch (...) {
43043       {
43044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43045       };
43046     }
43047   }
43048
43049   jresult = (void *)result;
43050   return jresult;
43051 }
43052
43053
43054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43055   int jresult ;
43056   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43057   Dali::Property::Type result;
43058
43059   arg1 = (Dali::KeyFrames *)jarg1;
43060   {
43061     try {
43062       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43063     } catch (std::out_of_range& e) {
43064       {
43065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43066       };
43067     } catch (std::exception& e) {
43068       {
43069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43070       };
43071     } catch (Dali::DaliException e) {
43072       {
43073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43074       };
43075     } catch (...) {
43076       {
43077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43078       };
43079     }
43080   }
43081
43082   jresult = (int)result;
43083   return jresult;
43084 }
43085
43086
43087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43088   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43089   float arg2 ;
43090   Dali::Property::Value arg3 ;
43091   Dali::Property::Value *argp3 ;
43092
43093   arg1 = (Dali::KeyFrames *)jarg1;
43094   arg2 = (float)jarg2;
43095   argp3 = (Dali::Property::Value *)jarg3;
43096   if (!argp3) {
43097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43098     return ;
43099   }
43100   arg3 = *argp3;
43101   {
43102     try {
43103       (arg1)->Add(arg2,arg3);
43104     } catch (std::out_of_range& e) {
43105       {
43106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43107       };
43108     } catch (std::exception& e) {
43109       {
43110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43111       };
43112     } catch (Dali::DaliException e) {
43113       {
43114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43115       };
43116     } catch (...) {
43117       {
43118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43119       };
43120     }
43121   }
43122
43123 }
43124
43125
43126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43127   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43128   float arg2 ;
43129   Dali::Property::Value arg3 ;
43130   Dali::AlphaFunction arg4 ;
43131   Dali::Property::Value *argp3 ;
43132   Dali::AlphaFunction *argp4 ;
43133
43134   arg1 = (Dali::KeyFrames *)jarg1;
43135   arg2 = (float)jarg2;
43136   argp3 = (Dali::Property::Value *)jarg3;
43137   if (!argp3) {
43138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43139     return ;
43140   }
43141   arg3 = *argp3;
43142   argp4 = (Dali::AlphaFunction *)jarg4;
43143   if (!argp4) {
43144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43145     return ;
43146   }
43147   arg4 = *argp4;
43148   {
43149     try {
43150       (arg1)->Add(arg2,arg3,arg4);
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43158       };
43159     } catch (Dali::DaliException e) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43166       };
43167     }
43168   }
43169
43170 }
43171
43172
43173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43174   int jresult ;
43175   int result;
43176
43177   result = (int)Dali::Path::Property::POINTS;
43178   jresult = (int)result;
43179   return jresult;
43180 }
43181
43182
43183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43184   int jresult ;
43185   int result;
43186
43187   result = (int)Dali::Path::Property::CONTROL_POINTS;
43188   jresult = (int)result;
43189   return jresult;
43190 }
43191
43192
43193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43194   void * jresult ;
43195   Dali::Path::Property *result = 0 ;
43196
43197   {
43198     try {
43199       result = (Dali::Path::Property *)new Dali::Path::Property();
43200     } catch (std::out_of_range& e) {
43201       {
43202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43203       };
43204     } catch (std::exception& e) {
43205       {
43206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43207       };
43208     } catch (Dali::DaliException e) {
43209       {
43210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43211       };
43212     } catch (...) {
43213       {
43214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43215       };
43216     }
43217   }
43218
43219   jresult = (void *)result;
43220   return jresult;
43221 }
43222
43223
43224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43225   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43226
43227   arg1 = (Dali::Path::Property *)jarg1;
43228   {
43229     try {
43230       delete arg1;
43231     } catch (std::out_of_range& e) {
43232       {
43233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43234       };
43235     } catch (std::exception& e) {
43236       {
43237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43238       };
43239     } catch (Dali::DaliException e) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43242       };
43243     } catch (...) {
43244       {
43245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43246       };
43247     }
43248   }
43249
43250 }
43251
43252
43253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43254   void * jresult ;
43255   Dali::Path result;
43256
43257   {
43258     try {
43259       result = Dali::Path::New();
43260     } catch (std::out_of_range& e) {
43261       {
43262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43263       };
43264     } catch (std::exception& e) {
43265       {
43266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43267       };
43268     } catch (Dali::DaliException e) {
43269       {
43270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43271       };
43272     } catch (...) {
43273       {
43274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43275       };
43276     }
43277   }
43278
43279   jresult = new Dali::Path((const Dali::Path &)result);
43280   return jresult;
43281 }
43282
43283
43284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43285   void * jresult ;
43286   Dali::BaseHandle arg1 ;
43287   Dali::BaseHandle *argp1 ;
43288   Dali::Path result;
43289
43290   argp1 = (Dali::BaseHandle *)jarg1;
43291   if (!argp1) {
43292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43293     return 0;
43294   }
43295   arg1 = *argp1;
43296   {
43297     try {
43298       result = Dali::Path::DownCast(arg1);
43299     } catch (std::out_of_range& e) {
43300       {
43301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43302       };
43303     } catch (std::exception& e) {
43304       {
43305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43306       };
43307     } catch (Dali::DaliException e) {
43308       {
43309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43310       };
43311     } catch (...) {
43312       {
43313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43314       };
43315     }
43316   }
43317
43318   jresult = new Dali::Path((const Dali::Path &)result);
43319   return jresult;
43320 }
43321
43322
43323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43324   void * jresult ;
43325   Dali::Path *result = 0 ;
43326
43327   {
43328     try {
43329       result = (Dali::Path *)new Dali::Path();
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (Dali::DaliException e) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43341       };
43342     } catch (...) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43345       };
43346     }
43347   }
43348
43349   jresult = (void *)result;
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43355   Dali::Path *arg1 = (Dali::Path *) 0 ;
43356
43357   arg1 = (Dali::Path *)jarg1;
43358   {
43359     try {
43360       delete arg1;
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (Dali::DaliException e) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43376       };
43377     }
43378   }
43379
43380 }
43381
43382
43383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43384   void * jresult ;
43385   Dali::Path *arg1 = 0 ;
43386   Dali::Path *result = 0 ;
43387
43388   arg1 = (Dali::Path *)jarg1;
43389   if (!arg1) {
43390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43391     return 0;
43392   }
43393   {
43394     try {
43395       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43396     } catch (std::out_of_range& e) {
43397       {
43398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43399       };
43400     } catch (std::exception& e) {
43401       {
43402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43403       };
43404     } catch (Dali::DaliException e) {
43405       {
43406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43407       };
43408     } catch (...) {
43409       {
43410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43411       };
43412     }
43413   }
43414
43415   jresult = (void *)result;
43416   return jresult;
43417 }
43418
43419
43420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43421   void * jresult ;
43422   Dali::Path *arg1 = (Dali::Path *) 0 ;
43423   Dali::Path *arg2 = 0 ;
43424   Dali::Path *result = 0 ;
43425
43426   arg1 = (Dali::Path *)jarg1;
43427   arg2 = (Dali::Path *)jarg2;
43428   if (!arg2) {
43429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43430     return 0;
43431   }
43432   {
43433     try {
43434       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43435     } catch (std::out_of_range& e) {
43436       {
43437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43438       };
43439     } catch (std::exception& e) {
43440       {
43441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43442       };
43443     } catch (Dali::DaliException e) {
43444       {
43445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43446       };
43447     } catch (...) {
43448       {
43449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43450       };
43451     }
43452   }
43453
43454   jresult = (void *)result;
43455   return jresult;
43456 }
43457
43458
43459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43460   Dali::Path *arg1 = (Dali::Path *) 0 ;
43461   Dali::Vector3 *arg2 = 0 ;
43462
43463   arg1 = (Dali::Path *)jarg1;
43464   arg2 = (Dali::Vector3 *)jarg2;
43465   if (!arg2) {
43466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43467     return ;
43468   }
43469   {
43470     try {
43471       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43472     } catch (std::out_of_range& e) {
43473       {
43474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43475       };
43476     } catch (std::exception& e) {
43477       {
43478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43479       };
43480     } catch (Dali::DaliException e) {
43481       {
43482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43483       };
43484     } catch (...) {
43485       {
43486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43487       };
43488     }
43489   }
43490
43491 }
43492
43493
43494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43495   Dali::Path *arg1 = (Dali::Path *) 0 ;
43496   Dali::Vector3 *arg2 = 0 ;
43497
43498   arg1 = (Dali::Path *)jarg1;
43499   arg2 = (Dali::Vector3 *)jarg2;
43500   if (!arg2) {
43501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43502     return ;
43503   }
43504   {
43505     try {
43506       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43507     } catch (std::out_of_range& e) {
43508       {
43509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43510       };
43511     } catch (std::exception& e) {
43512       {
43513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43514       };
43515     } catch (Dali::DaliException e) {
43516       {
43517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43518       };
43519     } catch (...) {
43520       {
43521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43522       };
43523     }
43524   }
43525
43526 }
43527
43528
43529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43530   Dali::Path *arg1 = (Dali::Path *) 0 ;
43531   float arg2 ;
43532
43533   arg1 = (Dali::Path *)jarg1;
43534   arg2 = (float)jarg2;
43535   {
43536     try {
43537       (arg1)->GenerateControlPoints(arg2);
43538     } catch (std::out_of_range& e) {
43539       {
43540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43541       };
43542     } catch (std::exception& e) {
43543       {
43544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43545       };
43546     } catch (Dali::DaliException e) {
43547       {
43548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43549       };
43550     } catch (...) {
43551       {
43552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43553       };
43554     }
43555   }
43556
43557 }
43558
43559
43560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43561   Dali::Path *arg1 = (Dali::Path *) 0 ;
43562   float arg2 ;
43563   Dali::Vector3 *arg3 = 0 ;
43564   Dali::Vector3 *arg4 = 0 ;
43565
43566   arg1 = (Dali::Path *)jarg1;
43567   arg2 = (float)jarg2;
43568   arg3 = (Dali::Vector3 *)jarg3;
43569   if (!arg3) {
43570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43571     return ;
43572   }
43573   arg4 = (Dali::Vector3 *)jarg4;
43574   if (!arg4) {
43575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43576     return ;
43577   }
43578   {
43579     try {
43580       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43581     } catch (std::out_of_range& e) {
43582       {
43583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43584       };
43585     } catch (std::exception& e) {
43586       {
43587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43588       };
43589     } catch (Dali::DaliException e) {
43590       {
43591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43592       };
43593     } catch (...) {
43594       {
43595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43596       };
43597     }
43598   }
43599
43600 }
43601
43602
43603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43604   void * jresult ;
43605   Dali::Path *arg1 = (Dali::Path *) 0 ;
43606   size_t arg2 ;
43607   Dali::Vector3 *result = 0 ;
43608
43609   arg1 = (Dali::Path *)jarg1;
43610   arg2 = (size_t)jarg2;
43611   {
43612     try {
43613       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43614     } catch (std::out_of_range& e) {
43615       {
43616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43617       };
43618     } catch (std::exception& e) {
43619       {
43620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43621       };
43622     } catch (Dali::DaliException e) {
43623       {
43624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43625       };
43626     } catch (...) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43629       };
43630     }
43631   }
43632
43633   jresult = (void *)result;
43634   return jresult;
43635 }
43636
43637
43638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43639   void * jresult ;
43640   Dali::Path *arg1 = (Dali::Path *) 0 ;
43641   size_t arg2 ;
43642   Dali::Vector3 *result = 0 ;
43643
43644   arg1 = (Dali::Path *)jarg1;
43645   arg2 = (size_t)jarg2;
43646   {
43647     try {
43648       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43649     } catch (std::out_of_range& e) {
43650       {
43651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43652       };
43653     } catch (std::exception& e) {
43654       {
43655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (Dali::DaliException e) {
43658       {
43659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43660       };
43661     } catch (...) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43664       };
43665     }
43666   }
43667
43668   jresult = (void *)result;
43669   return jresult;
43670 }
43671
43672
43673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43674   unsigned long jresult ;
43675   Dali::Path *arg1 = (Dali::Path *) 0 ;
43676   size_t result;
43677
43678   arg1 = (Dali::Path *)jarg1;
43679   {
43680     try {
43681       result = ((Dali::Path const *)arg1)->GetPointCount();
43682     } catch (std::out_of_range& e) {
43683       {
43684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (std::exception& e) {
43687       {
43688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (Dali::DaliException e) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43697       };
43698     }
43699   }
43700
43701   jresult = (unsigned long)result;
43702   return jresult;
43703 }
43704
43705
43706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43707   void * jresult ;
43708   float arg1 ;
43709   Dali::TimePeriod *result = 0 ;
43710
43711   arg1 = (float)jarg1;
43712   {
43713     try {
43714       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43715     } catch (std::out_of_range& e) {
43716       {
43717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (std::exception& e) {
43720       {
43721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (Dali::DaliException e) {
43724       {
43725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43730       };
43731     }
43732   }
43733
43734   jresult = (void *)result;
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43740   void * jresult ;
43741   float arg1 ;
43742   float arg2 ;
43743   Dali::TimePeriod *result = 0 ;
43744
43745   arg1 = (float)jarg1;
43746   arg2 = (float)jarg2;
43747   {
43748     try {
43749       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43750     } catch (std::out_of_range& e) {
43751       {
43752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43753       };
43754     } catch (std::exception& e) {
43755       {
43756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43757       };
43758     } catch (Dali::DaliException e) {
43759       {
43760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43761       };
43762     } catch (...) {
43763       {
43764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43765       };
43766     }
43767   }
43768
43769   jresult = (void *)result;
43770   return jresult;
43771 }
43772
43773
43774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43775   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43776
43777   arg1 = (Dali::TimePeriod *)jarg1;
43778   {
43779     try {
43780       delete arg1;
43781     } catch (std::out_of_range& e) {
43782       {
43783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43784       };
43785     } catch (std::exception& e) {
43786       {
43787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43788       };
43789     } catch (Dali::DaliException e) {
43790       {
43791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43792       };
43793     } catch (...) {
43794       {
43795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43796       };
43797     }
43798   }
43799
43800 }
43801
43802
43803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43804   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43805   float arg2 ;
43806
43807   arg1 = (Dali::TimePeriod *)jarg1;
43808   arg2 = (float)jarg2;
43809   if (arg1) (arg1)->delaySeconds = arg2;
43810 }
43811
43812
43813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43814   float jresult ;
43815   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43816   float result;
43817
43818   arg1 = (Dali::TimePeriod *)jarg1;
43819   result = (float) ((arg1)->delaySeconds);
43820   jresult = result;
43821   return jresult;
43822 }
43823
43824
43825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43826   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43827   float arg2 ;
43828
43829   arg1 = (Dali::TimePeriod *)jarg1;
43830   arg2 = (float)jarg2;
43831   if (arg1) (arg1)->durationSeconds = arg2;
43832 }
43833
43834
43835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43836   float jresult ;
43837   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43838   float result;
43839
43840   arg1 = (Dali::TimePeriod *)jarg1;
43841   result = (float) ((arg1)->durationSeconds);
43842   jresult = result;
43843   return jresult;
43844 }
43845
43846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43847   int jresult ;
43848   int result;
43849
43850   result = (int)Dali::LinearConstrainer::Property::VALUE;
43851   jresult = (int)result;
43852   return jresult;
43853 }
43854
43855
43856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43857   int jresult ;
43858   int result;
43859
43860   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43861   jresult = (int)result;
43862   return jresult;
43863 }
43864
43865
43866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43867   void * jresult ;
43868   Dali::LinearConstrainer::Property *result = 0 ;
43869
43870   {
43871     try {
43872       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43873     } catch (std::out_of_range& e) {
43874       {
43875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43876       };
43877     } catch (std::exception& e) {
43878       {
43879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43880       };
43881     } catch (Dali::DaliException e) {
43882       {
43883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43884       };
43885     } catch (...) {
43886       {
43887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43888       };
43889     }
43890   }
43891
43892   jresult = (void *)result;
43893   return jresult;
43894 }
43895
43896
43897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43898   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43899
43900   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43901   {
43902     try {
43903       delete arg1;
43904     } catch (std::out_of_range& e) {
43905       {
43906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43907       };
43908     } catch (std::exception& e) {
43909       {
43910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43911       };
43912     } catch (Dali::DaliException e) {
43913       {
43914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43915       };
43916     } catch (...) {
43917       {
43918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43919       };
43920     }
43921   }
43922
43923 }
43924
43925
43926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43927   void * jresult ;
43928   Dali::LinearConstrainer result;
43929
43930   {
43931     try {
43932       result = Dali::LinearConstrainer::New();
43933     } catch (std::out_of_range& e) {
43934       {
43935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43936       };
43937     } catch (std::exception& e) {
43938       {
43939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43940       };
43941     } catch (Dali::DaliException e) {
43942       {
43943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43944       };
43945     } catch (...) {
43946       {
43947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43948       };
43949     }
43950   }
43951
43952   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43953   return jresult;
43954 }
43955
43956
43957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43958   void * jresult ;
43959   Dali::BaseHandle arg1 ;
43960   Dali::BaseHandle *argp1 ;
43961   Dali::LinearConstrainer result;
43962
43963   argp1 = (Dali::BaseHandle *)jarg1;
43964   if (!argp1) {
43965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43966     return 0;
43967   }
43968   arg1 = *argp1;
43969   {
43970     try {
43971       result = Dali::LinearConstrainer::DownCast(arg1);
43972     } catch (std::out_of_range& e) {
43973       {
43974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43975       };
43976     } catch (std::exception& e) {
43977       {
43978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (Dali::DaliException e) {
43981       {
43982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43983       };
43984     } catch (...) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43987       };
43988     }
43989   }
43990
43991   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43992   return jresult;
43993 }
43994
43995
43996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43997   void * jresult ;
43998   Dali::LinearConstrainer *result = 0 ;
43999
44000   {
44001     try {
44002       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44018       };
44019     }
44020   }
44021
44022   jresult = (void *)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44028   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44029
44030   arg1 = (Dali::LinearConstrainer *)jarg1;
44031   {
44032     try {
44033       delete arg1;
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44049       };
44050     }
44051   }
44052
44053 }
44054
44055
44056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44057   void * jresult ;
44058   Dali::LinearConstrainer *arg1 = 0 ;
44059   Dali::LinearConstrainer *result = 0 ;
44060
44061   arg1 = (Dali::LinearConstrainer *)jarg1;
44062   if (!arg1) {
44063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44064     return 0;
44065   }
44066   {
44067     try {
44068       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44069     } catch (std::out_of_range& e) {
44070       {
44071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44072       };
44073     } catch (std::exception& e) {
44074       {
44075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44076       };
44077     } catch (Dali::DaliException e) {
44078       {
44079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44080       };
44081     } catch (...) {
44082       {
44083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44084       };
44085     }
44086   }
44087
44088   jresult = (void *)result;
44089   return jresult;
44090 }
44091
44092
44093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44094   void * jresult ;
44095   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44096   Dali::LinearConstrainer *arg2 = 0 ;
44097   Dali::LinearConstrainer *result = 0 ;
44098
44099   arg1 = (Dali::LinearConstrainer *)jarg1;
44100   arg2 = (Dali::LinearConstrainer *)jarg2;
44101   if (!arg2) {
44102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44103     return 0;
44104   }
44105   {
44106     try {
44107       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44108     } catch (std::out_of_range& e) {
44109       {
44110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44111       };
44112     } catch (std::exception& e) {
44113       {
44114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44115       };
44116     } catch (Dali::DaliException e) {
44117       {
44118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44119       };
44120     } catch (...) {
44121       {
44122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44123       };
44124     }
44125   }
44126
44127   jresult = (void *)result;
44128   return jresult;
44129 }
44130
44131
44132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44133   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44134   SwigValueWrapper< Dali::Property > arg2 ;
44135   SwigValueWrapper< Dali::Property > arg3 ;
44136   Dali::Vector2 *arg4 = 0 ;
44137   Dali::Vector2 *arg5 = 0 ;
44138   Dali::Property *argp2 ;
44139   Dali::Property *argp3 ;
44140
44141   arg1 = (Dali::LinearConstrainer *)jarg1;
44142   argp2 = (Dali::Property *)jarg2;
44143   if (!argp2) {
44144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44145     return ;
44146   }
44147   arg2 = *argp2;
44148   argp3 = (Dali::Property *)jarg3;
44149   if (!argp3) {
44150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44151     return ;
44152   }
44153   arg3 = *argp3;
44154   arg4 = (Dali::Vector2 *)jarg4;
44155   if (!arg4) {
44156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44157     return ;
44158   }
44159   arg5 = (Dali::Vector2 *)jarg5;
44160   if (!arg5) {
44161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44162     return ;
44163   }
44164   {
44165     try {
44166       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44167     } catch (std::out_of_range& e) {
44168       {
44169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44170       };
44171     } catch (std::exception& e) {
44172       {
44173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44174       };
44175     } catch (Dali::DaliException e) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44178       };
44179     } catch (...) {
44180       {
44181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44182       };
44183     }
44184   }
44185
44186 }
44187
44188
44189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44190   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44191   SwigValueWrapper< Dali::Property > arg2 ;
44192   SwigValueWrapper< Dali::Property > arg3 ;
44193   Dali::Vector2 *arg4 = 0 ;
44194   Dali::Property *argp2 ;
44195   Dali::Property *argp3 ;
44196
44197   arg1 = (Dali::LinearConstrainer *)jarg1;
44198   argp2 = (Dali::Property *)jarg2;
44199   if (!argp2) {
44200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44201     return ;
44202   }
44203   arg2 = *argp2;
44204   argp3 = (Dali::Property *)jarg3;
44205   if (!argp3) {
44206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44207     return ;
44208   }
44209   arg3 = *argp3;
44210   arg4 = (Dali::Vector2 *)jarg4;
44211   if (!arg4) {
44212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44213     return ;
44214   }
44215   {
44216     try {
44217       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44218     } catch (std::out_of_range& e) {
44219       {
44220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44221       };
44222     } catch (std::exception& e) {
44223       {
44224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44225       };
44226     } catch (Dali::DaliException e) {
44227       {
44228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44229       };
44230     } catch (...) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44233       };
44234     }
44235   }
44236
44237 }
44238
44239
44240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44241   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44242   Dali::Handle *arg2 = 0 ;
44243
44244   arg1 = (Dali::LinearConstrainer *)jarg1;
44245   arg2 = (Dali::Handle *)jarg2;
44246   if (!arg2) {
44247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44248     return ;
44249   }
44250   {
44251     try {
44252       (arg1)->Remove(*arg2);
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (Dali::DaliException e) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271
44272 }
44273
44274
44275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44276   int jresult ;
44277   int result;
44278
44279   result = (int)Dali::PathConstrainer::Property::FORWARD;
44280   jresult = (int)result;
44281   return jresult;
44282 }
44283
44284
44285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44286   int jresult ;
44287   int result;
44288
44289   result = (int)Dali::PathConstrainer::Property::POINTS;
44290   jresult = (int)result;
44291   return jresult;
44292 }
44293
44294
44295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44296   int jresult ;
44297   int result;
44298
44299   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44300   jresult = (int)result;
44301   return jresult;
44302 }
44303
44304
44305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44306   void * jresult ;
44307   Dali::PathConstrainer::Property *result = 0 ;
44308
44309   {
44310     try {
44311       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44312     } catch (std::out_of_range& e) {
44313       {
44314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44315       };
44316     } catch (std::exception& e) {
44317       {
44318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44319       };
44320     } catch (Dali::DaliException e) {
44321       {
44322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44323       };
44324     } catch (...) {
44325       {
44326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44327       };
44328     }
44329   }
44330
44331   jresult = (void *)result;
44332   return jresult;
44333 }
44334
44335
44336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44337   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44338
44339   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44340   {
44341     try {
44342       delete arg1;
44343     } catch (std::out_of_range& e) {
44344       {
44345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44346       };
44347     } catch (std::exception& e) {
44348       {
44349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44350       };
44351     } catch (Dali::DaliException e) {
44352       {
44353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44354       };
44355     } catch (...) {
44356       {
44357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44358       };
44359     }
44360   }
44361
44362 }
44363
44364
44365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44366   void * jresult ;
44367   Dali::PathConstrainer result;
44368
44369   {
44370     try {
44371       result = Dali::PathConstrainer::New();
44372     } catch (std::out_of_range& e) {
44373       {
44374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44375       };
44376     } catch (std::exception& e) {
44377       {
44378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44379       };
44380     } catch (Dali::DaliException e) {
44381       {
44382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44383       };
44384     } catch (...) {
44385       {
44386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44387       };
44388     }
44389   }
44390
44391   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44392   return jresult;
44393 }
44394
44395
44396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44397   void * jresult ;
44398   Dali::BaseHandle arg1 ;
44399   Dali::BaseHandle *argp1 ;
44400   Dali::PathConstrainer result;
44401
44402   argp1 = (Dali::BaseHandle *)jarg1;
44403   if (!argp1) {
44404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44405     return 0;
44406   }
44407   arg1 = *argp1;
44408   {
44409     try {
44410       result = Dali::PathConstrainer::DownCast(arg1);
44411     } catch (std::out_of_range& e) {
44412       {
44413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44414       };
44415     } catch (std::exception& e) {
44416       {
44417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44418       };
44419     } catch (Dali::DaliException e) {
44420       {
44421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44422       };
44423     } catch (...) {
44424       {
44425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44426       };
44427     }
44428   }
44429
44430   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44431   return jresult;
44432 }
44433
44434
44435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44436   void * jresult ;
44437   Dali::PathConstrainer *result = 0 ;
44438
44439   {
44440     try {
44441       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44442     } catch (std::out_of_range& e) {
44443       {
44444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44445       };
44446     } catch (std::exception& e) {
44447       {
44448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44449       };
44450     } catch (Dali::DaliException e) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44453       };
44454     } catch (...) {
44455       {
44456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44457       };
44458     }
44459   }
44460
44461   jresult = (void *)result;
44462   return jresult;
44463 }
44464
44465
44466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44467   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44468
44469   arg1 = (Dali::PathConstrainer *)jarg1;
44470   {
44471     try {
44472       delete arg1;
44473     } catch (std::out_of_range& e) {
44474       {
44475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (std::exception& e) {
44478       {
44479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (Dali::DaliException e) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44484       };
44485     } catch (...) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44488       };
44489     }
44490   }
44491
44492 }
44493
44494
44495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44496   void * jresult ;
44497   Dali::PathConstrainer *arg1 = 0 ;
44498   Dali::PathConstrainer *result = 0 ;
44499
44500   arg1 = (Dali::PathConstrainer *)jarg1;
44501   if (!arg1) {
44502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44503     return 0;
44504   }
44505   {
44506     try {
44507       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44508     } catch (std::out_of_range& e) {
44509       {
44510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44511       };
44512     } catch (std::exception& e) {
44513       {
44514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44515       };
44516     } catch (Dali::DaliException e) {
44517       {
44518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44519       };
44520     } catch (...) {
44521       {
44522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44523       };
44524     }
44525   }
44526
44527   jresult = (void *)result;
44528   return jresult;
44529 }
44530
44531
44532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44533   void * jresult ;
44534   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44535   Dali::PathConstrainer *arg2 = 0 ;
44536   Dali::PathConstrainer *result = 0 ;
44537
44538   arg1 = (Dali::PathConstrainer *)jarg1;
44539   arg2 = (Dali::PathConstrainer *)jarg2;
44540   if (!arg2) {
44541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44542     return 0;
44543   }
44544   {
44545     try {
44546       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44547     } catch (std::out_of_range& e) {
44548       {
44549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44550       };
44551     } catch (std::exception& e) {
44552       {
44553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44554       };
44555     } catch (Dali::DaliException e) {
44556       {
44557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44558       };
44559     } catch (...) {
44560       {
44561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44562       };
44563     }
44564   }
44565
44566   jresult = (void *)result;
44567   return jresult;
44568 }
44569
44570
44571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44572   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44573   SwigValueWrapper< Dali::Property > arg2 ;
44574   SwigValueWrapper< Dali::Property > arg3 ;
44575   Dali::Vector2 *arg4 = 0 ;
44576   Dali::Vector2 *arg5 = 0 ;
44577   Dali::Property *argp2 ;
44578   Dali::Property *argp3 ;
44579
44580   arg1 = (Dali::PathConstrainer *)jarg1;
44581   argp2 = (Dali::Property *)jarg2;
44582   if (!argp2) {
44583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44584     return ;
44585   }
44586   arg2 = *argp2;
44587   argp3 = (Dali::Property *)jarg3;
44588   if (!argp3) {
44589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44590     return ;
44591   }
44592   arg3 = *argp3;
44593   arg4 = (Dali::Vector2 *)jarg4;
44594   if (!arg4) {
44595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44596     return ;
44597   }
44598   arg5 = (Dali::Vector2 *)jarg5;
44599   if (!arg5) {
44600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44601     return ;
44602   }
44603   {
44604     try {
44605       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44606     } catch (std::out_of_range& e) {
44607       {
44608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44609       };
44610     } catch (std::exception& e) {
44611       {
44612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44613       };
44614     } catch (Dali::DaliException e) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44617       };
44618     } catch (...) {
44619       {
44620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44621       };
44622     }
44623   }
44624
44625 }
44626
44627
44628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44629   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44630   SwigValueWrapper< Dali::Property > arg2 ;
44631   SwigValueWrapper< Dali::Property > arg3 ;
44632   Dali::Vector2 *arg4 = 0 ;
44633   Dali::Property *argp2 ;
44634   Dali::Property *argp3 ;
44635
44636   arg1 = (Dali::PathConstrainer *)jarg1;
44637   argp2 = (Dali::Property *)jarg2;
44638   if (!argp2) {
44639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44640     return ;
44641   }
44642   arg2 = *argp2;
44643   argp3 = (Dali::Property *)jarg3;
44644   if (!argp3) {
44645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44646     return ;
44647   }
44648   arg3 = *argp3;
44649   arg4 = (Dali::Vector2 *)jarg4;
44650   if (!arg4) {
44651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44652     return ;
44653   }
44654   {
44655     try {
44656       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44657     } catch (std::out_of_range& e) {
44658       {
44659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44660       };
44661     } catch (std::exception& e) {
44662       {
44663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44664       };
44665     } catch (Dali::DaliException e) {
44666       {
44667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44668       };
44669     } catch (...) {
44670       {
44671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44672       };
44673     }
44674   }
44675
44676 }
44677
44678
44679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44680   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44681   Dali::Handle *arg2 = 0 ;
44682
44683   arg1 = (Dali::PathConstrainer *)jarg1;
44684   arg2 = (Dali::Handle *)jarg2;
44685   if (!arg2) {
44686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44687     return ;
44688   }
44689   {
44690     try {
44691       (arg1)->Remove(*arg2);
44692     } catch (std::out_of_range& e) {
44693       {
44694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (std::exception& e) {
44697       {
44698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44699       };
44700     } catch (Dali::DaliException e) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44703       };
44704     } catch (...) {
44705       {
44706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44707       };
44708     }
44709   }
44710
44711 }
44712
44713
44714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44715   int jresult ;
44716   Dali::FittingMode::Type result;
44717
44718   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44719   jresult = (int)result;
44720   return jresult;
44721 }
44722
44723
44724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44725   int jresult ;
44726   Dali::SamplingMode::Type result;
44727
44728   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44729   jresult = (int)result;
44730   return jresult;
44731 }
44732
44733
44734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44735   unsigned int jresult ;
44736   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44737   bool result;
44738
44739   arg1 = (Dali::NativeImageInterface *)jarg1;
44740   {
44741     try {
44742       result = (bool)(arg1)->CreateResource();
44743     } catch (std::out_of_range& e) {
44744       {
44745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44746       };
44747     } catch (std::exception& e) {
44748       {
44749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44750       };
44751     } catch (Dali::DaliException e) {
44752       {
44753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44754       };
44755     } catch (...) {
44756       {
44757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44758       };
44759     }
44760   }
44761
44762   jresult = result;
44763   return jresult;
44764 }
44765
44766
44767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44768   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44769
44770   arg1 = (Dali::NativeImageInterface *)jarg1;
44771   {
44772     try {
44773       (arg1)->DestroyResource();
44774     } catch (std::out_of_range& e) {
44775       {
44776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44777       };
44778     } catch (std::exception& e) {
44779       {
44780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44781       };
44782     } catch (Dali::DaliException e) {
44783       {
44784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44785       };
44786     } catch (...) {
44787       {
44788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44789       };
44790     }
44791   }
44792
44793 }
44794
44795
44796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44797   unsigned int jresult ;
44798   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44799   unsigned int result;
44800
44801   arg1 = (Dali::NativeImageInterface *)jarg1;
44802   {
44803     try {
44804       result = (unsigned int)(arg1)->TargetTexture();
44805     } catch (std::out_of_range& e) {
44806       {
44807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44808       };
44809     } catch (std::exception& e) {
44810       {
44811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44812       };
44813     } catch (Dali::DaliException e) {
44814       {
44815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44816       };
44817     } catch (...) {
44818       {
44819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44820       };
44821     }
44822   }
44823
44824   jresult = result;
44825   return jresult;
44826 }
44827
44828
44829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44830   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44831
44832   arg1 = (Dali::NativeImageInterface *)jarg1;
44833   {
44834     try {
44835       (arg1)->PrepareTexture();
44836     } catch (std::out_of_range& e) {
44837       {
44838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44839       };
44840     } catch (std::exception& e) {
44841       {
44842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44843       };
44844     } catch (Dali::DaliException e) {
44845       {
44846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44847       };
44848     } catch (...) {
44849       {
44850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44851       };
44852     }
44853   }
44854
44855 }
44856
44857
44858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44859   unsigned int jresult ;
44860   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44861   unsigned int result;
44862
44863   arg1 = (Dali::NativeImageInterface *)jarg1;
44864   {
44865     try {
44866       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44867     } catch (std::out_of_range& e) {
44868       {
44869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44870       };
44871     } catch (std::exception& e) {
44872       {
44873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44874       };
44875     } catch (Dali::DaliException e) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44878       };
44879     } catch (...) {
44880       {
44881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44882       };
44883     }
44884   }
44885
44886   jresult = result;
44887   return jresult;
44888 }
44889
44890
44891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44892   unsigned int jresult ;
44893   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44894   unsigned int result;
44895
44896   arg1 = (Dali::NativeImageInterface *)jarg1;
44897   {
44898     try {
44899       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44900     } catch (std::out_of_range& e) {
44901       {
44902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44903       };
44904     } catch (std::exception& e) {
44905       {
44906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44907       };
44908     } catch (Dali::DaliException e) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44911       };
44912     } catch (...) {
44913       {
44914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44915       };
44916     }
44917   }
44918
44919   jresult = result;
44920   return jresult;
44921 }
44922
44923
44924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44925   unsigned int jresult ;
44926   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44927   bool result;
44928
44929   arg1 = (Dali::NativeImageInterface *)jarg1;
44930   {
44931     try {
44932       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44940       };
44941     } catch (Dali::DaliException e) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44944       };
44945     } catch (...) {
44946       {
44947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44948       };
44949     }
44950   }
44951
44952   jresult = result;
44953   return jresult;
44954 }
44955
44956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44957   int jresult ;
44958   int result;
44959
44960   result = (int)Dali::CameraActor::Property::TYPE;
44961   jresult = (int)result;
44962   return jresult;
44963 }
44964
44965
44966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44967   int jresult ;
44968   int result;
44969
44970   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44971   jresult = (int)result;
44972   return jresult;
44973 }
44974
44975
44976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44977   int jresult ;
44978   int result;
44979
44980   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44981   jresult = (int)result;
44982   return jresult;
44983 }
44984
44985
44986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44987   int jresult ;
44988   int result;
44989
44990   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44991   jresult = (int)result;
44992   return jresult;
44993 }
44994
44995
44996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44997   int jresult ;
44998   int result;
44999
45000   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
45001   jresult = (int)result;
45002   return jresult;
45003 }
45004
45005
45006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
45007   int jresult ;
45008   int result;
45009
45010   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
45011   jresult = (int)result;
45012   return jresult;
45013 }
45014
45015
45016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
45017   int jresult ;
45018   int result;
45019
45020   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
45021   jresult = (int)result;
45022   return jresult;
45023 }
45024
45025
45026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
45027   int jresult ;
45028   int result;
45029
45030   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
45031   jresult = (int)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
45037   int jresult ;
45038   int result;
45039
45040   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
45041   jresult = (int)result;
45042   return jresult;
45043 }
45044
45045
45046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
45047   int jresult ;
45048   int result;
45049
45050   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
45051   jresult = (int)result;
45052   return jresult;
45053 }
45054
45055
45056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
45057   int jresult ;
45058   int result;
45059
45060   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
45061   jresult = (int)result;
45062   return jresult;
45063 }
45064
45065
45066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
45067   int jresult ;
45068   int result;
45069
45070   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
45071   jresult = (int)result;
45072   return jresult;
45073 }
45074
45075
45076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
45077   int jresult ;
45078   int result;
45079
45080   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
45081   jresult = (int)result;
45082   return jresult;
45083 }
45084
45085
45086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
45087   int jresult ;
45088   int result;
45089
45090   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
45091   jresult = (int)result;
45092   return jresult;
45093 }
45094
45095
45096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
45097   void * jresult ;
45098   Dali::CameraActor::Property *result = 0 ;
45099
45100   {
45101     try {
45102       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
45103     } catch (std::out_of_range& e) {
45104       {
45105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45106       };
45107     } catch (std::exception& e) {
45108       {
45109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (Dali::DaliException e) {
45112       {
45113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45114       };
45115     } catch (...) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45118       };
45119     }
45120   }
45121
45122   jresult = (void *)result;
45123   return jresult;
45124 }
45125
45126
45127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
45128   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
45129
45130   arg1 = (Dali::CameraActor::Property *)jarg1;
45131   {
45132     try {
45133       delete arg1;
45134     } catch (std::out_of_range& e) {
45135       {
45136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45137       };
45138     } catch (std::exception& e) {
45139       {
45140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45141       };
45142     } catch (Dali::DaliException e) {
45143       {
45144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45145       };
45146     } catch (...) {
45147       {
45148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45149       };
45150     }
45151   }
45152
45153 }
45154
45155
45156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
45157   void * jresult ;
45158   Dali::CameraActor *result = 0 ;
45159
45160   {
45161     try {
45162       result = (Dali::CameraActor *)new Dali::CameraActor();
45163     } catch (std::out_of_range& e) {
45164       {
45165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (std::exception& e) {
45168       {
45169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45170       };
45171     } catch (Dali::DaliException e) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45174       };
45175     } catch (...) {
45176       {
45177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45178       };
45179     }
45180   }
45181
45182   jresult = (void *)result;
45183   return jresult;
45184 }
45185
45186
45187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45188   void * jresult ;
45189   Dali::CameraActor result;
45190
45191   {
45192     try {
45193       result = Dali::CameraActor::New();
45194     } catch (std::out_of_range& e) {
45195       {
45196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45197       };
45198     } catch (std::exception& e) {
45199       {
45200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (Dali::DaliException e) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45209       };
45210     }
45211   }
45212
45213   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45214   return jresult;
45215 }
45216
45217
45218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45219   void * jresult ;
45220   Dali::Size *arg1 = 0 ;
45221   Dali::CameraActor result;
45222
45223   arg1 = (Dali::Size *)jarg1;
45224   if (!arg1) {
45225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45226     return 0;
45227   }
45228   {
45229     try {
45230       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45231     } catch (std::out_of_range& e) {
45232       {
45233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (std::exception& e) {
45236       {
45237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (Dali::DaliException e) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45242       };
45243     } catch (...) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45246       };
45247     }
45248   }
45249
45250   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45251   return jresult;
45252 }
45253
45254
45255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45256   void * jresult ;
45257   Dali::BaseHandle arg1 ;
45258   Dali::BaseHandle *argp1 ;
45259   Dali::CameraActor result;
45260
45261   argp1 = (Dali::BaseHandle *)jarg1;
45262   if (!argp1) {
45263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45264     return 0;
45265   }
45266   arg1 = *argp1;
45267   {
45268     try {
45269       result = Dali::CameraActor::DownCast(arg1);
45270     } catch (std::out_of_range& e) {
45271       {
45272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45273       };
45274     } catch (std::exception& e) {
45275       {
45276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45277       };
45278     } catch (Dali::DaliException e) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45281       };
45282     } catch (...) {
45283       {
45284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45285       };
45286     }
45287   }
45288
45289   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45290   return jresult;
45291 }
45292
45293
45294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45295   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45296
45297   arg1 = (Dali::CameraActor *)jarg1;
45298   {
45299     try {
45300       delete arg1;
45301     } catch (std::out_of_range& e) {
45302       {
45303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45304       };
45305     } catch (std::exception& e) {
45306       {
45307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45308       };
45309     } catch (Dali::DaliException e) {
45310       {
45311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45312       };
45313     } catch (...) {
45314       {
45315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45316       };
45317     }
45318   }
45319
45320 }
45321
45322
45323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45324   void * jresult ;
45325   Dali::CameraActor *arg1 = 0 ;
45326   Dali::CameraActor *result = 0 ;
45327
45328   arg1 = (Dali::CameraActor *)jarg1;
45329   if (!arg1) {
45330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45331     return 0;
45332   }
45333   {
45334     try {
45335       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45336     } catch (std::out_of_range& e) {
45337       {
45338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45339       };
45340     } catch (std::exception& e) {
45341       {
45342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45343       };
45344     } catch (Dali::DaliException e) {
45345       {
45346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45347       };
45348     } catch (...) {
45349       {
45350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45351       };
45352     }
45353   }
45354
45355   jresult = (void *)result;
45356   return jresult;
45357 }
45358
45359
45360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45361   void * jresult ;
45362   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45363   Dali::CameraActor *arg2 = 0 ;
45364   Dali::CameraActor *result = 0 ;
45365
45366   arg1 = (Dali::CameraActor *)jarg1;
45367   arg2 = (Dali::CameraActor *)jarg2;
45368   if (!arg2) {
45369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45370     return 0;
45371   }
45372   {
45373     try {
45374       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45375     } catch (std::out_of_range& e) {
45376       {
45377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (std::exception& e) {
45380       {
45381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45382       };
45383     } catch (Dali::DaliException e) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45386       };
45387     } catch (...) {
45388       {
45389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45390       };
45391     }
45392   }
45393
45394   jresult = (void *)result;
45395   return jresult;
45396 }
45397
45398
45399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45400   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45401   Dali::Camera::Type arg2 ;
45402
45403   arg1 = (Dali::CameraActor *)jarg1;
45404   arg2 = (Dali::Camera::Type)jarg2;
45405   {
45406     try {
45407       (arg1)->SetType(arg2);
45408     } catch (std::out_of_range& e) {
45409       {
45410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45411       };
45412     } catch (std::exception& e) {
45413       {
45414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45415       };
45416     } catch (Dali::DaliException e) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45419       };
45420     } catch (...) {
45421       {
45422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45423       };
45424     }
45425   }
45426
45427 }
45428
45429
45430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45431   int jresult ;
45432   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45433   Dali::Camera::Type result;
45434
45435   arg1 = (Dali::CameraActor *)jarg1;
45436   {
45437     try {
45438       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45439     } catch (std::out_of_range& e) {
45440       {
45441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45442       };
45443     } catch (std::exception& e) {
45444       {
45445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45446       };
45447     } catch (Dali::DaliException e) {
45448       {
45449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45450       };
45451     } catch (...) {
45452       {
45453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45454       };
45455     }
45456   }
45457
45458   jresult = (int)result;
45459   return jresult;
45460 }
45461
45462
45463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45464   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45465   Dali::Camera::ProjectionMode arg2 ;
45466
45467   arg1 = (Dali::CameraActor *)jarg1;
45468   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45469   {
45470     try {
45471       (arg1)->SetProjectionMode(arg2);
45472     } catch (std::out_of_range& e) {
45473       {
45474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45475       };
45476     } catch (std::exception& e) {
45477       {
45478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45479       };
45480     } catch (Dali::DaliException e) {
45481       {
45482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45483       };
45484     } catch (...) {
45485       {
45486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45487       };
45488     }
45489   }
45490
45491 }
45492
45493
45494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45495   int jresult ;
45496   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45497   Dali::Camera::ProjectionMode result;
45498
45499   arg1 = (Dali::CameraActor *)jarg1;
45500   {
45501     try {
45502       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45503     } catch (std::out_of_range& e) {
45504       {
45505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45506       };
45507     } catch (std::exception& e) {
45508       {
45509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45510       };
45511     } catch (Dali::DaliException e) {
45512       {
45513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45514       };
45515     } catch (...) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45518       };
45519     }
45520   }
45521
45522   jresult = (int)result;
45523   return jresult;
45524 }
45525
45526
45527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45528   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45529   float arg2 ;
45530
45531   arg1 = (Dali::CameraActor *)jarg1;
45532   arg2 = (float)jarg2;
45533   {
45534     try {
45535       (arg1)->SetFieldOfView(arg2);
45536     } catch (std::out_of_range& e) {
45537       {
45538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45539       };
45540     } catch (std::exception& e) {
45541       {
45542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45543       };
45544     } catch (Dali::DaliException e) {
45545       {
45546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45547       };
45548     } catch (...) {
45549       {
45550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45551       };
45552     }
45553   }
45554
45555 }
45556
45557
45558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45559   float jresult ;
45560   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45561   float result;
45562
45563   arg1 = (Dali::CameraActor *)jarg1;
45564   {
45565     try {
45566       result = (float)(arg1)->GetFieldOfView();
45567     } catch (std::out_of_range& e) {
45568       {
45569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45570       };
45571     } catch (std::exception& e) {
45572       {
45573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45574       };
45575     } catch (Dali::DaliException e) {
45576       {
45577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45578       };
45579     } catch (...) {
45580       {
45581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45582       };
45583     }
45584   }
45585
45586   jresult = result;
45587   return jresult;
45588 }
45589
45590
45591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45592   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45593   float arg2 ;
45594
45595   arg1 = (Dali::CameraActor *)jarg1;
45596   arg2 = (float)jarg2;
45597   {
45598     try {
45599       (arg1)->SetAspectRatio(arg2);
45600     } catch (std::out_of_range& e) {
45601       {
45602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45603       };
45604     } catch (std::exception& e) {
45605       {
45606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45607       };
45608     } catch (Dali::DaliException e) {
45609       {
45610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45611       };
45612     } catch (...) {
45613       {
45614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45615       };
45616     }
45617   }
45618
45619 }
45620
45621
45622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45623   float jresult ;
45624   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45625   float result;
45626
45627   arg1 = (Dali::CameraActor *)jarg1;
45628   {
45629     try {
45630       result = (float)(arg1)->GetAspectRatio();
45631     } catch (std::out_of_range& e) {
45632       {
45633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45634       };
45635     } catch (std::exception& e) {
45636       {
45637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45638       };
45639     } catch (Dali::DaliException e) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45642       };
45643     } catch (...) {
45644       {
45645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45646       };
45647     }
45648   }
45649
45650   jresult = result;
45651   return jresult;
45652 }
45653
45654
45655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45656   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45657   float arg2 ;
45658
45659   arg1 = (Dali::CameraActor *)jarg1;
45660   arg2 = (float)jarg2;
45661   {
45662     try {
45663       (arg1)->SetNearClippingPlane(arg2);
45664     } catch (std::out_of_range& e) {
45665       {
45666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45667       };
45668     } catch (std::exception& e) {
45669       {
45670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45671       };
45672     } catch (Dali::DaliException e) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45675       };
45676     } catch (...) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45679       };
45680     }
45681   }
45682
45683 }
45684
45685
45686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45687   float jresult ;
45688   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45689   float result;
45690
45691   arg1 = (Dali::CameraActor *)jarg1;
45692   {
45693     try {
45694       result = (float)(arg1)->GetNearClippingPlane();
45695     } catch (std::out_of_range& e) {
45696       {
45697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (std::exception& e) {
45700       {
45701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45702       };
45703     } catch (Dali::DaliException e) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45710       };
45711     }
45712   }
45713
45714   jresult = result;
45715   return jresult;
45716 }
45717
45718
45719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45720   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45721   float arg2 ;
45722
45723   arg1 = (Dali::CameraActor *)jarg1;
45724   arg2 = (float)jarg2;
45725   {
45726     try {
45727       (arg1)->SetFarClippingPlane(arg2);
45728     } catch (std::out_of_range& e) {
45729       {
45730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45731       };
45732     } catch (std::exception& e) {
45733       {
45734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45735       };
45736     } catch (Dali::DaliException e) {
45737       {
45738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45739       };
45740     } catch (...) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45743       };
45744     }
45745   }
45746
45747 }
45748
45749
45750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45751   float jresult ;
45752   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45753   float result;
45754
45755   arg1 = (Dali::CameraActor *)jarg1;
45756   {
45757     try {
45758       result = (float)(arg1)->GetFarClippingPlane();
45759     } catch (std::out_of_range& e) {
45760       {
45761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45762       };
45763     } catch (std::exception& e) {
45764       {
45765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45766       };
45767     } catch (Dali::DaliException e) {
45768       {
45769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45770       };
45771     } catch (...) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45774       };
45775     }
45776   }
45777
45778   jresult = result;
45779   return jresult;
45780 }
45781
45782
45783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45784   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45785   Dali::Vector3 *arg2 = 0 ;
45786
45787   arg1 = (Dali::CameraActor *)jarg1;
45788   arg2 = (Dali::Vector3 *)jarg2;
45789   if (!arg2) {
45790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45791     return ;
45792   }
45793   {
45794     try {
45795       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45796     } catch (std::out_of_range& e) {
45797       {
45798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45799       };
45800     } catch (std::exception& e) {
45801       {
45802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45803       };
45804     } catch (Dali::DaliException e) {
45805       {
45806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45807       };
45808     } catch (...) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45811       };
45812     }
45813   }
45814
45815 }
45816
45817
45818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45819   void * jresult ;
45820   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45821   Dali::Vector3 result;
45822
45823   arg1 = (Dali::CameraActor *)jarg1;
45824   {
45825     try {
45826       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45827     } catch (std::out_of_range& e) {
45828       {
45829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45830       };
45831     } catch (std::exception& e) {
45832       {
45833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45834       };
45835     } catch (Dali::DaliException e) {
45836       {
45837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45838       };
45839     } catch (...) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45842       };
45843     }
45844   }
45845
45846   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45847   return jresult;
45848 }
45849
45850
45851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45852   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45853   bool arg2 ;
45854
45855   arg1 = (Dali::CameraActor *)jarg1;
45856   arg2 = jarg2 ? true : false;
45857   {
45858     try {
45859       (arg1)->SetInvertYAxis(arg2);
45860     } catch (std::out_of_range& e) {
45861       {
45862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45863       };
45864     } catch (std::exception& e) {
45865       {
45866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45867       };
45868     } catch (Dali::DaliException e) {
45869       {
45870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45871       };
45872     } catch (...) {
45873       {
45874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45875       };
45876     }
45877   }
45878
45879 }
45880
45881
45882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45883   unsigned int jresult ;
45884   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45885   bool result;
45886
45887   arg1 = (Dali::CameraActor *)jarg1;
45888   {
45889     try {
45890       result = (bool)(arg1)->GetInvertYAxis();
45891     } catch (std::out_of_range& e) {
45892       {
45893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45894       };
45895     } catch (std::exception& e) {
45896       {
45897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45898       };
45899     } catch (Dali::DaliException e) {
45900       {
45901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45902       };
45903     } catch (...) {
45904       {
45905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45906       };
45907     }
45908   }
45909
45910   jresult = result;
45911   return jresult;
45912 }
45913
45914
45915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45916   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45917   Dali::Size *arg2 = 0 ;
45918
45919   arg1 = (Dali::CameraActor *)jarg1;
45920   arg2 = (Dali::Size *)jarg2;
45921   if (!arg2) {
45922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45923     return ;
45924   }
45925   {
45926     try {
45927       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45928     } catch (std::out_of_range& e) {
45929       {
45930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45931       };
45932     } catch (std::exception& e) {
45933       {
45934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45935       };
45936     } catch (Dali::DaliException e) {
45937       {
45938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45939       };
45940     } catch (...) {
45941       {
45942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45943       };
45944     }
45945   }
45946
45947 }
45948
45949
45950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45951   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45952   Dali::Size *arg2 = 0 ;
45953
45954   arg1 = (Dali::CameraActor *)jarg1;
45955   arg2 = (Dali::Size *)jarg2;
45956   if (!arg2) {
45957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45958     return ;
45959   }
45960   {
45961     try {
45962       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45963     } catch (std::out_of_range& e) {
45964       {
45965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45966       };
45967     } catch (std::exception& e) {
45968       {
45969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45970       };
45971     } catch (Dali::DaliException e) {
45972       {
45973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45974       };
45975     } catch (...) {
45976       {
45977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45978       };
45979     }
45980   }
45981
45982 }
45983
45984
45985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45986   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45987   float arg2 ;
45988   float arg3 ;
45989   float arg4 ;
45990   float arg5 ;
45991   float arg6 ;
45992   float arg7 ;
45993
45994   arg1 = (Dali::CameraActor *)jarg1;
45995   arg2 = (float)jarg2;
45996   arg3 = (float)jarg3;
45997   arg4 = (float)jarg4;
45998   arg5 = (float)jarg5;
45999   arg6 = (float)jarg6;
46000   arg7 = (float)jarg7;
46001   {
46002     try {
46003       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
46004     } catch (std::out_of_range& e) {
46005       {
46006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46007       };
46008     } catch (std::exception& e) {
46009       {
46010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46011       };
46012     } catch (Dali::DaliException e) {
46013       {
46014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46015       };
46016     } catch (...) {
46017       {
46018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46019       };
46020     }
46021   }
46022
46023 }
46024
46025
46026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
46027   void * jresult ;
46028   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46029
46030   {
46031     try {
46032       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
46033     } catch (std::out_of_range& e) {
46034       {
46035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46036       };
46037     } catch (std::exception& e) {
46038       {
46039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (Dali::DaliException e) {
46042       {
46043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46044       };
46045     } catch (...) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46048       };
46049     }
46050   }
46051
46052   jresult = (void *)result;
46053   return jresult;
46054 }
46055
46056
46057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
46058   void * jresult ;
46059   std::string arg1 ;
46060   Dali::Property::Value arg2 ;
46061   Dali::Property::Value *argp2 ;
46062   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46063
46064   if (!jarg1) {
46065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46066     return 0;
46067   }
46068   (&arg1)->assign(jarg1);
46069   argp2 = (Dali::Property::Value *)jarg2;
46070   if (!argp2) {
46071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
46072     return 0;
46073   }
46074   arg2 = *argp2;
46075   {
46076     try {
46077       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
46078     } catch (std::out_of_range& e) {
46079       {
46080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46081       };
46082     } catch (std::exception& e) {
46083       {
46084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46085       };
46086     } catch (Dali::DaliException e) {
46087       {
46088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46089       };
46090     } catch (...) {
46091       {
46092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46093       };
46094     }
46095   }
46096
46097   jresult = (void *)result;
46098   return jresult;
46099 }
46100
46101
46102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
46103   void * jresult ;
46104   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
46105   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46106
46107   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46108   if (!arg1) {
46109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
46110     return 0;
46111   }
46112   {
46113     try {
46114       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);
46115     } catch (std::out_of_range& e) {
46116       {
46117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46118       };
46119     } catch (std::exception& e) {
46120       {
46121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46122       };
46123     } catch (Dali::DaliException e) {
46124       {
46125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46126       };
46127     } catch (...) {
46128       {
46129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46130       };
46131     }
46132   }
46133
46134   jresult = (void *)result;
46135   return jresult;
46136 }
46137
46138
46139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
46140   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46141   std::string *arg2 = 0 ;
46142
46143   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46144   if (!jarg2) {
46145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46146     return ;
46147   }
46148   std::string arg2_str(jarg2);
46149   arg2 = &arg2_str;
46150   if (arg1) (arg1)->first = *arg2;
46151
46152   //argout typemap for const std::string&
46153
46154 }
46155
46156
46157 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
46158   char * jresult ;
46159   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46160   std::string *result = 0 ;
46161
46162   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46163   result = (std::string *) & ((arg1)->first);
46164   jresult = SWIG_csharp_string_callback(result->c_str());
46165   return jresult;
46166 }
46167
46168
46169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
46170   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46171   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
46172
46173   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46174   arg2 = (Dali::Property::Value *)jarg2;
46175   if (arg1) (arg1)->second = *arg2;
46176 }
46177
46178
46179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46180   void * jresult ;
46181   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46182   Dali::Property::Value *result = 0 ;
46183
46184   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46185   result = (Dali::Property::Value *)& ((arg1)->second);
46186   jresult = (void *)result;
46187   return jresult;
46188 }
46189
46190
46191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46192   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46193
46194   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46195   {
46196     try {
46197       delete arg1;
46198     } catch (std::out_of_range& e) {
46199       {
46200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46201       };
46202     } catch (std::exception& e) {
46203       {
46204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46205       };
46206     } catch (Dali::DaliException e) {
46207       {
46208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46209       };
46210     } catch (...) {
46211       {
46212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46213       };
46214     }
46215   }
46216
46217 }
46218
46219
46220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46221   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46222
46223   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46224   {
46225     try {
46226       (arg1)->clear();
46227     } catch (std::out_of_range& e) {
46228       {
46229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46230       };
46231     } catch (std::exception& e) {
46232       {
46233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46234       };
46235     } catch (Dali::DaliException e) {
46236       {
46237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46238       };
46239     } catch (...) {
46240       {
46241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46242       };
46243     }
46244   }
46245
46246 }
46247
46248
46249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46250   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46251   Dali::TouchPoint *arg2 = 0 ;
46252
46253   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46254   arg2 = (Dali::TouchPoint *)jarg2;
46255   if (!arg2) {
46256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46257     return ;
46258   }
46259   {
46260     try {
46261       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46262     } catch (std::out_of_range& e) {
46263       {
46264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46265       };
46266     } catch (std::exception& e) {
46267       {
46268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46269       };
46270     } catch (Dali::DaliException e) {
46271       {
46272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46273       };
46274     } catch (...) {
46275       {
46276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46277       };
46278     }
46279   }
46280
46281 }
46282
46283
46284 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46285   unsigned long jresult ;
46286   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46287   std::vector< Dali::TouchPoint >::size_type result;
46288
46289   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46290   {
46291     try {
46292       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46300       };
46301     } catch (Dali::DaliException e) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46304       };
46305     } catch (...) {
46306       {
46307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46308       };
46309     }
46310   }
46311
46312   jresult = (unsigned long)result;
46313   return jresult;
46314 }
46315
46316
46317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46318   unsigned long jresult ;
46319   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46320   std::vector< Dali::TouchPoint >::size_type result;
46321
46322   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46323   {
46324     try {
46325       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46326     } catch (std::out_of_range& e) {
46327       {
46328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46329       };
46330     } catch (std::exception& e) {
46331       {
46332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46333       };
46334     } catch (Dali::DaliException e) {
46335       {
46336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46337       };
46338     } catch (...) {
46339       {
46340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46341       };
46342     }
46343   }
46344
46345   jresult = (unsigned long)result;
46346   return jresult;
46347 }
46348
46349
46350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46351   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46352   std::vector< Dali::TouchPoint >::size_type arg2 ;
46353
46354   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46355   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46356   {
46357     try {
46358       (arg1)->reserve(arg2);
46359     } catch (std::out_of_range& e) {
46360       {
46361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46362       };
46363     } catch (std::exception& e) {
46364       {
46365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46366       };
46367     } catch (Dali::DaliException e) {
46368       {
46369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46370       };
46371     } catch (...) {
46372       {
46373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46374       };
46375     }
46376   }
46377
46378 }
46379
46380
46381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46382   void * jresult ;
46383   std::vector< Dali::TouchPoint > *result = 0 ;
46384
46385   {
46386     try {
46387       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46388     } catch (std::out_of_range& e) {
46389       {
46390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46391       };
46392     } catch (std::exception& e) {
46393       {
46394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46395       };
46396     } catch (Dali::DaliException e) {
46397       {
46398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46399       };
46400     } catch (...) {
46401       {
46402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46403       };
46404     }
46405   }
46406
46407   jresult = (void *)result;
46408   return jresult;
46409 }
46410
46411
46412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46413   void * jresult ;
46414   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46415   std::vector< Dali::TouchPoint > *result = 0 ;
46416
46417   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46418   if (!arg1) {
46419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46420     return 0;
46421   }
46422   {
46423     try {
46424       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46425     } catch (std::out_of_range& e) {
46426       {
46427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46428       };
46429     } catch (std::exception& e) {
46430       {
46431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46432       };
46433     } catch (Dali::DaliException e) {
46434       {
46435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46436       };
46437     } catch (...) {
46438       {
46439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46440       };
46441     }
46442   }
46443
46444   jresult = (void *)result;
46445   return jresult;
46446 }
46447
46448
46449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46450   void * jresult ;
46451   int arg1 ;
46452   std::vector< Dali::TouchPoint > *result = 0 ;
46453
46454   arg1 = (int)jarg1;
46455   {
46456     try {
46457       try {
46458         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46459       }
46460       catch(std::out_of_range &_e) {
46461         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46462         return 0;
46463       }
46464
46465     } catch (std::out_of_range& e) {
46466       {
46467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46468       };
46469     } catch (std::exception& e) {
46470       {
46471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (Dali::DaliException e) {
46474       {
46475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46476       };
46477     } catch (...) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46480       };
46481     }
46482   }
46483
46484   jresult = (void *)result;
46485   return jresult;
46486 }
46487
46488
46489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46490   void * jresult ;
46491   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46492   int arg2 ;
46493   SwigValueWrapper< Dali::TouchPoint > result;
46494
46495   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46496   arg2 = (int)jarg2;
46497   {
46498     try {
46499       try {
46500         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46501       }
46502       catch(std::out_of_range &_e) {
46503         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46504         return 0;
46505       }
46506
46507     } catch (std::out_of_range& e) {
46508       {
46509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46510       };
46511     } catch (std::exception& e) {
46512       {
46513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (Dali::DaliException e) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46518       };
46519     } catch (...) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46522       };
46523     }
46524   }
46525
46526   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46532   void * jresult ;
46533   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46534   int arg2 ;
46535   Dali::TouchPoint *result = 0 ;
46536
46537   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46538   arg2 = (int)jarg2;
46539   {
46540     try {
46541       try {
46542         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46543       }
46544       catch(std::out_of_range &_e) {
46545         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46546         return 0;
46547       }
46548
46549     } catch (std::out_of_range& e) {
46550       {
46551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46552       };
46553     } catch (std::exception& e) {
46554       {
46555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46556       };
46557     } catch (Dali::DaliException e) {
46558       {
46559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46560       };
46561     } catch (...) {
46562       {
46563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46564       };
46565     }
46566   }
46567
46568   jresult = (void *)result;
46569   return jresult;
46570 }
46571
46572
46573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46574   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46575   int arg2 ;
46576   Dali::TouchPoint *arg3 = 0 ;
46577
46578   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46579   arg2 = (int)jarg2;
46580   arg3 = (Dali::TouchPoint *)jarg3;
46581   if (!arg3) {
46582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46583     return ;
46584   }
46585   {
46586     try {
46587       try {
46588         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46589       }
46590       catch(std::out_of_range &_e) {
46591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46592         return ;
46593       }
46594
46595     } catch (std::out_of_range& e) {
46596       {
46597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46598       };
46599     } catch (std::exception& e) {
46600       {
46601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46602       };
46603     } catch (Dali::DaliException e) {
46604       {
46605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46606       };
46607     } catch (...) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46610       };
46611     }
46612   }
46613
46614 }
46615
46616
46617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46618   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46619   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46620
46621   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46622   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46623   if (!arg2) {
46624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46625     return ;
46626   }
46627   {
46628     try {
46629       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46630     } catch (std::out_of_range& e) {
46631       {
46632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46633       };
46634     } catch (std::exception& e) {
46635       {
46636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46637       };
46638     } catch (Dali::DaliException e) {
46639       {
46640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46645       };
46646     }
46647   }
46648
46649 }
46650
46651
46652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46653   void * jresult ;
46654   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46655   int arg2 ;
46656   int arg3 ;
46657   std::vector< Dali::TouchPoint > *result = 0 ;
46658
46659   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46660   arg2 = (int)jarg2;
46661   arg3 = (int)jarg3;
46662   {
46663     try {
46664       try {
46665         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46666       }
46667       catch(std::out_of_range &_e) {
46668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46669         return 0;
46670       }
46671       catch(std::invalid_argument &_e) {
46672         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46673         return 0;
46674       }
46675
46676     } catch (std::out_of_range& e) {
46677       {
46678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (std::exception& e) {
46681       {
46682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46683       };
46684     } catch (Dali::DaliException e) {
46685       {
46686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46687       };
46688     } catch (...) {
46689       {
46690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46691       };
46692     }
46693   }
46694
46695   jresult = (void *)result;
46696   return jresult;
46697 }
46698
46699
46700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46701   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46702   int arg2 ;
46703   Dali::TouchPoint *arg3 = 0 ;
46704
46705   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46706   arg2 = (int)jarg2;
46707   arg3 = (Dali::TouchPoint *)jarg3;
46708   if (!arg3) {
46709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46710     return ;
46711   }
46712   {
46713     try {
46714       try {
46715         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46716       }
46717       catch(std::out_of_range &_e) {
46718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46719         return ;
46720       }
46721
46722     } catch (std::out_of_range& e) {
46723       {
46724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46725       };
46726     } catch (std::exception& e) {
46727       {
46728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46729       };
46730     } catch (Dali::DaliException e) {
46731       {
46732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46733       };
46734     } catch (...) {
46735       {
46736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46737       };
46738     }
46739   }
46740
46741 }
46742
46743
46744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46745   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46746   int arg2 ;
46747   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46748
46749   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46750   arg2 = (int)jarg2;
46751   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46752   if (!arg3) {
46753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46754     return ;
46755   }
46756   {
46757     try {
46758       try {
46759         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46760       }
46761       catch(std::out_of_range &_e) {
46762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46763         return ;
46764       }
46765
46766     } catch (std::out_of_range& e) {
46767       {
46768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46769       };
46770     } catch (std::exception& e) {
46771       {
46772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46773       };
46774     } catch (Dali::DaliException e) {
46775       {
46776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46777       };
46778     } catch (...) {
46779       {
46780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46781       };
46782     }
46783   }
46784
46785 }
46786
46787
46788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46789   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46790   int arg2 ;
46791
46792   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46793   arg2 = (int)jarg2;
46794   {
46795     try {
46796       try {
46797         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46798       }
46799       catch(std::out_of_range &_e) {
46800         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46801         return ;
46802       }
46803
46804     } catch (std::out_of_range& e) {
46805       {
46806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46807       };
46808     } catch (std::exception& e) {
46809       {
46810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46811       };
46812     } catch (Dali::DaliException e) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46815       };
46816     } catch (...) {
46817       {
46818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46819       };
46820     }
46821   }
46822
46823 }
46824
46825
46826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46827   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46828   int arg2 ;
46829   int arg3 ;
46830
46831   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46832   arg2 = (int)jarg2;
46833   arg3 = (int)jarg3;
46834   {
46835     try {
46836       try {
46837         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46838       }
46839       catch(std::out_of_range &_e) {
46840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46841         return ;
46842       }
46843       catch(std::invalid_argument &_e) {
46844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46845         return ;
46846       }
46847
46848     } catch (std::out_of_range& e) {
46849       {
46850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46851       };
46852     } catch (std::exception& e) {
46853       {
46854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46855       };
46856     } catch (Dali::DaliException e) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46859       };
46860     } catch (...) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46863       };
46864     }
46865   }
46866
46867 }
46868
46869
46870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46871   void * jresult ;
46872   Dali::TouchPoint *arg1 = 0 ;
46873   int arg2 ;
46874   std::vector< Dali::TouchPoint > *result = 0 ;
46875
46876   arg1 = (Dali::TouchPoint *)jarg1;
46877   if (!arg1) {
46878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46879     return 0;
46880   }
46881   arg2 = (int)jarg2;
46882   {
46883     try {
46884       try {
46885         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46886       }
46887       catch(std::out_of_range &_e) {
46888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46889         return 0;
46890       }
46891
46892     } catch (std::out_of_range& e) {
46893       {
46894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46895       };
46896     } catch (std::exception& e) {
46897       {
46898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46899       };
46900     } catch (Dali::DaliException e) {
46901       {
46902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46903       };
46904     } catch (...) {
46905       {
46906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46907       };
46908     }
46909   }
46910
46911   jresult = (void *)result;
46912   return jresult;
46913 }
46914
46915
46916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46917   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46918
46919   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46920   {
46921     try {
46922       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46923     } catch (std::out_of_range& e) {
46924       {
46925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46926       };
46927     } catch (std::exception& e) {
46928       {
46929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46930       };
46931     } catch (Dali::DaliException e) {
46932       {
46933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46934       };
46935     } catch (...) {
46936       {
46937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46938       };
46939     }
46940   }
46941
46942 }
46943
46944
46945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46946   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46947   int arg2 ;
46948   int arg3 ;
46949
46950   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46951   arg2 = (int)jarg2;
46952   arg3 = (int)jarg3;
46953   {
46954     try {
46955       try {
46956         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46957       }
46958       catch(std::out_of_range &_e) {
46959         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46960         return ;
46961       }
46962       catch(std::invalid_argument &_e) {
46963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46964         return ;
46965       }
46966
46967     } catch (std::out_of_range& e) {
46968       {
46969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46970       };
46971     } catch (std::exception& e) {
46972       {
46973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46974       };
46975     } catch (Dali::DaliException e) {
46976       {
46977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46978       };
46979     } catch (...) {
46980       {
46981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46982       };
46983     }
46984   }
46985
46986 }
46987
46988
46989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46990   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46991   int arg2 ;
46992   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46993
46994   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46995   arg2 = (int)jarg2;
46996   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46997   if (!arg3) {
46998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46999     return ;
47000   }
47001   {
47002     try {
47003       try {
47004         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47005       }
47006       catch(std::out_of_range &_e) {
47007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47008         return ;
47009       }
47010
47011     } catch (std::out_of_range& e) {
47012       {
47013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47014       };
47015     } catch (std::exception& e) {
47016       {
47017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47018       };
47019     } catch (Dali::DaliException e) {
47020       {
47021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47022       };
47023     } catch (...) {
47024       {
47025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47026       };
47027     }
47028   }
47029
47030 }
47031
47032
47033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
47034   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47035
47036   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47037   {
47038     try {
47039       delete arg1;
47040     } catch (std::out_of_range& e) {
47041       {
47042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (std::exception& e) {
47045       {
47046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47047       };
47048     } catch (Dali::DaliException e) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47051       };
47052     } catch (...) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47055       };
47056     }
47057   }
47058
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
47063   void * jresult ;
47064   Dali::Rect< int > *result = 0 ;
47065
47066   {
47067     try {
47068       result = (Dali::Rect< int > *)new Dali::Rect< int >();
47069     } catch (std::out_of_range& e) {
47070       {
47071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47072       };
47073     } catch (std::exception& e) {
47074       {
47075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47076       };
47077     } catch (Dali::DaliException e) {
47078       {
47079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47080       };
47081     } catch (...) {
47082       {
47083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47084       };
47085     }
47086   }
47087
47088   jresult = (void *)result;
47089   return jresult;
47090 }
47091
47092
47093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
47094   void * jresult ;
47095   int arg1 ;
47096   int arg2 ;
47097   int arg3 ;
47098   int arg4 ;
47099   Dali::Rect< int > *result = 0 ;
47100
47101   arg1 = (int)jarg1;
47102   arg2 = (int)jarg2;
47103   arg3 = (int)jarg3;
47104   arg4 = (int)jarg4;
47105   {
47106     try {
47107       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
47108     } catch (std::out_of_range& e) {
47109       {
47110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (std::exception& e) {
47113       {
47114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47115       };
47116     } catch (Dali::DaliException e) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47119       };
47120     } catch (...) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47123       };
47124     }
47125   }
47126
47127   jresult = (void *)result;
47128   return jresult;
47129 }
47130
47131
47132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
47133   void * jresult ;
47134   Dali::Rect< int > *arg1 = 0 ;
47135   Dali::Rect< int > *result = 0 ;
47136
47137   arg1 = (Dali::Rect< int > *)jarg1;
47138   if (!arg1) {
47139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47140     return 0;
47141   }
47142   {
47143     try {
47144       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
47145     } catch (std::out_of_range& e) {
47146       {
47147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (std::exception& e) {
47150       {
47151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (Dali::DaliException e) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47156       };
47157     } catch (...) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47160       };
47161     }
47162   }
47163
47164   jresult = (void *)result;
47165   return jresult;
47166 }
47167
47168
47169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
47170   void * jresult ;
47171   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47172   Dali::Rect< int > *arg2 = 0 ;
47173   Dali::Rect< int > *result = 0 ;
47174
47175   arg1 = (Dali::Rect< int > *)jarg1;
47176   arg2 = (Dali::Rect< int > *)jarg2;
47177   if (!arg2) {
47178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47179     return 0;
47180   }
47181   {
47182     try {
47183       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (Dali::DaliException e) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47195       };
47196     } catch (...) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47199       };
47200     }
47201   }
47202
47203   jresult = (void *)result;
47204   return jresult;
47205 }
47206
47207
47208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47209   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47210   int arg2 ;
47211   int arg3 ;
47212   int arg4 ;
47213   int arg5 ;
47214
47215   arg1 = (Dali::Rect< int > *)jarg1;
47216   arg2 = (int)jarg2;
47217   arg3 = (int)jarg3;
47218   arg4 = (int)jarg4;
47219   arg5 = (int)jarg5;
47220   {
47221     try {
47222       (arg1)->Set(arg2,arg3,arg4,arg5);
47223     } catch (std::out_of_range& e) {
47224       {
47225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47226       };
47227     } catch (std::exception& e) {
47228       {
47229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47230       };
47231     } catch (Dali::DaliException e) {
47232       {
47233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47234       };
47235     } catch (...) {
47236       {
47237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47238       };
47239     }
47240   }
47241
47242 }
47243
47244
47245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47246   unsigned int jresult ;
47247   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47248   bool result;
47249
47250   arg1 = (Dali::Rect< int > *)jarg1;
47251   {
47252     try {
47253       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47254     } catch (std::out_of_range& e) {
47255       {
47256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47257       };
47258     } catch (std::exception& e) {
47259       {
47260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47261       };
47262     } catch (Dali::DaliException e) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47265       };
47266     } catch (...) {
47267       {
47268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47269       };
47270     }
47271   }
47272
47273   jresult = result;
47274   return jresult;
47275 }
47276
47277
47278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47279   int jresult ;
47280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47281   int result;
47282
47283   arg1 = (Dali::Rect< int > *)jarg1;
47284   {
47285     try {
47286       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47287     } catch (std::out_of_range& e) {
47288       {
47289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47290       };
47291     } catch (std::exception& e) {
47292       {
47293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47294       };
47295     } catch (Dali::DaliException e) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47298       };
47299     } catch (...) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47302       };
47303     }
47304   }
47305
47306   jresult = result;
47307   return jresult;
47308 }
47309
47310
47311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47312   int jresult ;
47313   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47314   int result;
47315
47316   arg1 = (Dali::Rect< int > *)jarg1;
47317   {
47318     try {
47319       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47320     } catch (std::out_of_range& e) {
47321       {
47322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47323       };
47324     } catch (std::exception& e) {
47325       {
47326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (Dali::DaliException e) {
47329       {
47330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47331       };
47332     } catch (...) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47335       };
47336     }
47337   }
47338
47339   jresult = result;
47340   return jresult;
47341 }
47342
47343
47344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47345   int jresult ;
47346   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47347   int result;
47348
47349   arg1 = (Dali::Rect< int > *)jarg1;
47350   {
47351     try {
47352       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47353     } catch (std::out_of_range& e) {
47354       {
47355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (std::exception& e) {
47358       {
47359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47360       };
47361     } catch (Dali::DaliException e) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47364       };
47365     } catch (...) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47368       };
47369     }
47370   }
47371
47372   jresult = result;
47373   return jresult;
47374 }
47375
47376
47377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47378   int jresult ;
47379   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47380   int result;
47381
47382   arg1 = (Dali::Rect< int > *)jarg1;
47383   {
47384     try {
47385       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47386     } catch (std::out_of_range& e) {
47387       {
47388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47389       };
47390     } catch (std::exception& e) {
47391       {
47392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47393       };
47394     } catch (Dali::DaliException e) {
47395       {
47396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47397       };
47398     } catch (...) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47401       };
47402     }
47403   }
47404
47405   jresult = result;
47406   return jresult;
47407 }
47408
47409
47410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47411   int jresult ;
47412   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47413   int result;
47414
47415   arg1 = (Dali::Rect< int > *)jarg1;
47416   {
47417     try {
47418       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47419     } catch (std::out_of_range& e) {
47420       {
47421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (std::exception& e) {
47424       {
47425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47426       };
47427     } catch (Dali::DaliException e) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47430       };
47431     } catch (...) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47434       };
47435     }
47436   }
47437
47438   jresult = result;
47439   return jresult;
47440 }
47441
47442
47443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47444   unsigned int jresult ;
47445   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47446   Dali::Rect< int > *arg2 = 0 ;
47447   bool result;
47448
47449   arg1 = (Dali::Rect< int > *)jarg1;
47450   arg2 = (Dali::Rect< int > *)jarg2;
47451   if (!arg2) {
47452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47453     return 0;
47454   }
47455   {
47456     try {
47457       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47458     } catch (std::out_of_range& e) {
47459       {
47460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (std::exception& e) {
47463       {
47464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (Dali::DaliException e) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47469       };
47470     } catch (...) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47473       };
47474     }
47475   }
47476
47477   jresult = result;
47478   return jresult;
47479 }
47480
47481
47482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47483   unsigned int jresult ;
47484   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47485   Dali::Rect< int > *arg2 = 0 ;
47486   bool result;
47487
47488   arg1 = (Dali::Rect< int > *)jarg1;
47489   arg2 = (Dali::Rect< int > *)jarg2;
47490   if (!arg2) {
47491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47492     return 0;
47493   }
47494   {
47495     try {
47496       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47497     } catch (std::out_of_range& e) {
47498       {
47499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47500       };
47501     } catch (std::exception& e) {
47502       {
47503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47504       };
47505     } catch (Dali::DaliException e) {
47506       {
47507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47508       };
47509     } catch (...) {
47510       {
47511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47512       };
47513     }
47514   }
47515
47516   jresult = result;
47517   return jresult;
47518 }
47519
47520
47521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47522   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47523   int arg2 ;
47524
47525   arg1 = (Dali::Rect< int > *)jarg1;
47526   arg2 = (int)jarg2;
47527   if (arg1) (arg1)->x = arg2;
47528 }
47529
47530
47531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47532   int jresult ;
47533   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47534   int result;
47535
47536   arg1 = (Dali::Rect< int > *)jarg1;
47537   result = (int) ((arg1)->x);
47538   jresult = result;
47539   return jresult;
47540 }
47541
47542
47543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47544   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47545   int arg2 ;
47546
47547   arg1 = (Dali::Rect< int > *)jarg1;
47548   arg2 = (int)jarg2;
47549   if (arg1) (arg1)->left = arg2;
47550 }
47551
47552
47553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47554   int jresult ;
47555   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47556   int result;
47557
47558   arg1 = (Dali::Rect< int > *)jarg1;
47559   result = (int) ((arg1)->left);
47560   jresult = result;
47561   return jresult;
47562 }
47563
47564
47565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47566   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47567   int arg2 ;
47568
47569   arg1 = (Dali::Rect< int > *)jarg1;
47570   arg2 = (int)jarg2;
47571   if (arg1) (arg1)->y = arg2;
47572 }
47573
47574
47575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47576   int jresult ;
47577   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47578   int result;
47579
47580   arg1 = (Dali::Rect< int > *)jarg1;
47581   result = (int) ((arg1)->y);
47582   jresult = result;
47583   return jresult;
47584 }
47585
47586
47587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47588   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47589   int arg2 ;
47590
47591   arg1 = (Dali::Rect< int > *)jarg1;
47592   arg2 = (int)jarg2;
47593   if (arg1) (arg1)->right = arg2;
47594 }
47595
47596
47597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47598   int jresult ;
47599   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47600   int result;
47601
47602   arg1 = (Dali::Rect< int > *)jarg1;
47603   result = (int) ((arg1)->right);
47604   jresult = result;
47605   return jresult;
47606 }
47607
47608
47609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47610   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47611   int arg2 ;
47612
47613   arg1 = (Dali::Rect< int > *)jarg1;
47614   arg2 = (int)jarg2;
47615   if (arg1) (arg1)->width = arg2;
47616 }
47617
47618
47619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47620   int jresult ;
47621   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47622   int result;
47623
47624   arg1 = (Dali::Rect< int > *)jarg1;
47625   result = (int) ((arg1)->width);
47626   jresult = result;
47627   return jresult;
47628 }
47629
47630
47631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47632   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47633   int arg2 ;
47634
47635   arg1 = (Dali::Rect< int > *)jarg1;
47636   arg2 = (int)jarg2;
47637   if (arg1) (arg1)->bottom = arg2;
47638 }
47639
47640
47641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47642   int jresult ;
47643   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47644   int result;
47645
47646   arg1 = (Dali::Rect< int > *)jarg1;
47647   result = (int) ((arg1)->bottom);
47648   jresult = result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47654   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47655   int arg2 ;
47656
47657   arg1 = (Dali::Rect< int > *)jarg1;
47658   arg2 = (int)jarg2;
47659   if (arg1) (arg1)->height = arg2;
47660 }
47661
47662
47663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47664   int jresult ;
47665   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47666   int result;
47667
47668   arg1 = (Dali::Rect< int > *)jarg1;
47669   result = (int) ((arg1)->height);
47670   jresult = result;
47671   return jresult;
47672 }
47673
47674
47675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47676   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47677   int arg2 ;
47678
47679   arg1 = (Dali::Rect< int > *)jarg1;
47680   arg2 = (int)jarg2;
47681   if (arg1) (arg1)->top = arg2;
47682 }
47683
47684
47685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47686   int jresult ;
47687   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47688   int result;
47689
47690   arg1 = (Dali::Rect< int > *)jarg1;
47691   result = (int) ((arg1)->top);
47692   jresult = result;
47693   return jresult;
47694 }
47695
47696
47697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47698   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47699
47700   arg1 = (Dali::Rect< int > *)jarg1;
47701   {
47702     try {
47703       delete arg1;
47704     } catch (std::out_of_range& e) {
47705       {
47706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47707       };
47708     } catch (std::exception& e) {
47709       {
47710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47711       };
47712     } catch (Dali::DaliException e) {
47713       {
47714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47715       };
47716     } catch (...) {
47717       {
47718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47719       };
47720     }
47721   }
47722
47723 }
47724
47725
47726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47727   void * jresult ;
47728   Dali::Rect< float > *result = 0 ;
47729
47730   {
47731     try {
47732       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47733     } catch (std::out_of_range& e) {
47734       {
47735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47736       };
47737     } catch (std::exception& e) {
47738       {
47739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47740       };
47741     } catch (Dali::DaliException e) {
47742       {
47743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47744       };
47745     } catch (...) {
47746       {
47747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47748       };
47749     }
47750   }
47751
47752   jresult = (void *)result;
47753   return jresult;
47754 }
47755
47756
47757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47758   void * jresult ;
47759   float arg1 ;
47760   float arg2 ;
47761   float arg3 ;
47762   float arg4 ;
47763   Dali::Rect< float > *result = 0 ;
47764
47765   arg1 = (float)jarg1;
47766   arg2 = (float)jarg2;
47767   arg3 = (float)jarg4;
47768   arg4 = (float)jarg3;
47769   {
47770     try {
47771       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47772     } catch (std::out_of_range& e) {
47773       {
47774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47775       };
47776     } catch (std::exception& e) {
47777       {
47778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (Dali::DaliException e) {
47781       {
47782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47783       };
47784     } catch (...) {
47785       {
47786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47787       };
47788     }
47789   }
47790
47791   jresult = (void *)result;
47792   return jresult;
47793 }
47794
47795
47796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47797   void * jresult ;
47798   Dali::Rect< float > *arg1 = 0 ;
47799   Dali::Rect< float > *result = 0 ;
47800
47801   arg1 = (Dali::Rect< float > *)jarg1;
47802   if (!arg1) {
47803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47804     return 0;
47805   }
47806   {
47807     try {
47808       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47809     } catch (std::out_of_range& e) {
47810       {
47811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47812       };
47813     } catch (std::exception& e) {
47814       {
47815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (Dali::DaliException e) {
47818       {
47819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827
47828   jresult = (void *)result;
47829   return jresult;
47830 }
47831
47832
47833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47834   void * jresult ;
47835   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47836   Dali::Rect< float > *arg2 = 0 ;
47837   Dali::Rect< float > *result = 0 ;
47838
47839   arg1 = (Dali::Rect< float > *)jarg1;
47840   arg2 = (Dali::Rect< float > *)jarg2;
47841   if (!arg2) {
47842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47843     return 0;
47844   }
47845   {
47846     try {
47847       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47848     } catch (std::out_of_range& e) {
47849       {
47850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47851       };
47852     } catch (std::exception& e) {
47853       {
47854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47855       };
47856     } catch (Dali::DaliException e) {
47857       {
47858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47859       };
47860     } catch (...) {
47861       {
47862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47863       };
47864     }
47865   }
47866
47867   jresult = (void *)result;
47868   return jresult;
47869 }
47870
47871
47872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47873   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47874   float arg2 ;
47875   float arg3 ;
47876   float arg4 ;
47877   float arg5 ;
47878
47879   arg1 = (Dali::Rect< float > *)jarg1;
47880   arg2 = (float)jarg2;
47881   arg3 = (float)jarg3;
47882   arg4 = (float)jarg5;
47883   arg5 = (float)jarg4;
47884   {
47885     try {
47886       (arg1)->Set(arg2,arg3,arg4,arg5);
47887     } catch (std::out_of_range& e) {
47888       {
47889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47890       };
47891     } catch (std::exception& e) {
47892       {
47893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47894       };
47895     } catch (Dali::DaliException e) {
47896       {
47897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47898       };
47899     } catch (...) {
47900       {
47901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47902       };
47903     }
47904   }
47905
47906 }
47907
47908
47909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47910   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47911   float arg2 ;
47912
47913   arg1 = (Dali::Rect< float > *)jarg1;
47914   arg2 = (float)jarg2;
47915   if (arg1) (arg1)->left = arg2;
47916 }
47917
47918
47919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47920   float jresult ;
47921   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47922   float result;
47923
47924   arg1 = (Dali::Rect< float > *)jarg1;
47925   result = (float) ((arg1)->left);
47926   jresult = result;
47927   return jresult;
47928 }
47929
47930
47931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47932   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47933   float arg2 ;
47934
47935   arg1 = (Dali::Rect< float > *)jarg1;
47936   arg2 = (float)jarg2;
47937   if (arg1) (arg1)->left = arg2;
47938 }
47939
47940
47941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47942   float jresult ;
47943   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47944   float result;
47945
47946   arg1 = (Dali::Rect< float > *)jarg1;
47947   result = (float) ((arg1)->left);
47948   jresult = result;
47949   return jresult;
47950 }
47951
47952
47953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47954   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47955   float arg2 ;
47956
47957   arg1 = (Dali::Rect< float > *)jarg1;
47958   arg2 = (float)jarg2;
47959   if (arg1) (arg1)->right = arg2;
47960 }
47961
47962
47963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47964   float jresult ;
47965   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47966   float result;
47967
47968   arg1 = (Dali::Rect< float > *)jarg1;
47969   result = (float) ((arg1)->right);
47970   jresult = result;
47971   return jresult;
47972 }
47973
47974
47975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47976   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47977   float arg2 ;
47978
47979   arg1 = (Dali::Rect< float > *)jarg1;
47980   arg2 = (float)jarg2;
47981   if (arg1) (arg1)->right = arg2;
47982 }
47983
47984
47985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47986   float jresult ;
47987   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47988   float result;
47989
47990   arg1 = (Dali::Rect< float > *)jarg1;
47991   result = (float) ((arg1)->right);
47992   jresult = result;
47993   return jresult;
47994 }
47995
47996
47997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47998   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47999   float arg2 ;
48000
48001   arg1 = (Dali::Rect< float > *)jarg1;
48002   arg2 = (float)jarg2;
48003   if (arg1) (arg1)->bottom = arg2;
48004 }
48005
48006
48007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
48008   float jresult ;
48009   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48010   float result;
48011
48012   arg1 = (Dali::Rect< float > *)jarg1;
48013   result = (float) ((arg1)->bottom);
48014   jresult = result;
48015   return jresult;
48016 }
48017
48018
48019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
48020   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48021   float arg2 ;
48022
48023   arg1 = (Dali::Rect< float > *)jarg1;
48024   arg2 = (float)jarg2;
48025   if (arg1) (arg1)->top = arg2;
48026 }
48027
48028
48029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
48030   float jresult ;
48031   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48032   float result;
48033
48034   arg1 = (Dali::Rect< float > *)jarg1;
48035   result = (float) ((arg1)->top);
48036   jresult = result;
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
48042   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48043
48044   arg1 = (Dali::Rect< float > *)jarg1;
48045   {
48046     try {
48047       delete arg1;
48048     } catch (std::out_of_range& e) {
48049       {
48050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48051       };
48052     } catch (std::exception& e) {
48053       {
48054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48055       };
48056     } catch (Dali::DaliException e) {
48057       {
48058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48059       };
48060     } catch (...) {
48061       {
48062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48063       };
48064     }
48065   }
48066
48067 }
48068
48069
48070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
48071   int jresult ;
48072   int result;
48073
48074   result = (int)Dali::Vector< int >::BaseType;
48075   jresult = (int)result;
48076   return jresult;
48077 }
48078
48079
48080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
48081   void * jresult ;
48082   Dali::Vector< int > *result = 0 ;
48083
48084   {
48085     try {
48086       result = (Dali::Vector< int > *)new Dali::Vector< int >();
48087     } catch (std::out_of_range& e) {
48088       {
48089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48090       };
48091     } catch (std::exception& e) {
48092       {
48093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48094       };
48095     } catch (Dali::DaliException e) {
48096       {
48097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48098       };
48099     } catch (...) {
48100       {
48101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48102       };
48103     }
48104   }
48105
48106   jresult = (void *)result;
48107   return jresult;
48108 }
48109
48110
48111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
48112   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48113
48114   arg1 = (Dali::Vector< int > *)jarg1;
48115   {
48116     try {
48117       delete arg1;
48118     } catch (std::out_of_range& e) {
48119       {
48120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48121       };
48122     } catch (std::exception& e) {
48123       {
48124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48125       };
48126     } catch (Dali::DaliException e) {
48127       {
48128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48129       };
48130     } catch (...) {
48131       {
48132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48133       };
48134     }
48135   }
48136
48137 }
48138
48139
48140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
48141   void * jresult ;
48142   Dali::Vector< int > *arg1 = 0 ;
48143   Dali::Vector< int > *result = 0 ;
48144
48145   arg1 = (Dali::Vector< int > *)jarg1;
48146   if (!arg1) {
48147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48148     return 0;
48149   }
48150   {
48151     try {
48152       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
48153     } catch (std::out_of_range& e) {
48154       {
48155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48156       };
48157     } catch (std::exception& e) {
48158       {
48159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48160       };
48161     } catch (Dali::DaliException e) {
48162       {
48163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48164       };
48165     } catch (...) {
48166       {
48167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48168       };
48169     }
48170   }
48171
48172   jresult = (void *)result;
48173   return jresult;
48174 }
48175
48176
48177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48178   void * jresult ;
48179   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48180   Dali::Vector< int > *arg2 = 0 ;
48181   Dali::Vector< int > *result = 0 ;
48182
48183   arg1 = (Dali::Vector< int > *)jarg1;
48184   arg2 = (Dali::Vector< int > *)jarg2;
48185   if (!arg2) {
48186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48187     return 0;
48188   }
48189   {
48190     try {
48191       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48192     } catch (std::out_of_range& e) {
48193       {
48194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48195       };
48196     } catch (std::exception& e) {
48197       {
48198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (Dali::DaliException e) {
48201       {
48202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48203       };
48204     } catch (...) {
48205       {
48206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48207       };
48208     }
48209   }
48210
48211   jresult = (void *)result;
48212   return jresult;
48213 }
48214
48215
48216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48217   void * jresult ;
48218   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48219   Dali::Vector< int >::Iterator result;
48220
48221   arg1 = (Dali::Vector< int > *)jarg1;
48222   {
48223     try {
48224       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48225     } catch (std::out_of_range& e) {
48226       {
48227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48228       };
48229     } catch (std::exception& e) {
48230       {
48231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48232       };
48233     } catch (Dali::DaliException e) {
48234       {
48235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48236       };
48237     } catch (...) {
48238       {
48239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48240       };
48241     }
48242   }
48243
48244   jresult = (void *)result;
48245   return jresult;
48246 }
48247
48248
48249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48250   void * jresult ;
48251   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48252   Dali::Vector< int >::Iterator result;
48253
48254   arg1 = (Dali::Vector< int > *)jarg1;
48255   {
48256     try {
48257       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48258     } catch (std::out_of_range& e) {
48259       {
48260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48261       };
48262     } catch (std::exception& e) {
48263       {
48264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48265       };
48266     } catch (Dali::DaliException e) {
48267       {
48268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48269       };
48270     } catch (...) {
48271       {
48272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48273       };
48274     }
48275   }
48276
48277   jresult = (void *)result;
48278   return jresult;
48279 }
48280
48281
48282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48283   void * jresult ;
48284   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48285   Dali::Vector< int >::SizeType arg2 ;
48286   Dali::Vector< int >::ItemType *result = 0 ;
48287
48288   arg1 = (Dali::Vector< int > *)jarg1;
48289   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48290   {
48291     try {
48292       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48293     } catch (std::out_of_range& e) {
48294       {
48295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48296       };
48297     } catch (std::exception& e) {
48298       {
48299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48300       };
48301     } catch (Dali::DaliException e) {
48302       {
48303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48304       };
48305     } catch (...) {
48306       {
48307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48308       };
48309     }
48310   }
48311
48312   jresult = (void *)result;
48313   return jresult;
48314 }
48315
48316
48317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48318   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48319   Dali::Vector< int >::ItemType *arg2 = 0 ;
48320   Dali::Vector< int >::ItemType temp2 ;
48321
48322   arg1 = (Dali::Vector< int > *)jarg1;
48323   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48324   arg2 = &temp2;
48325   {
48326     try {
48327       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48328     } catch (std::out_of_range& e) {
48329       {
48330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48331       };
48332     } catch (std::exception& e) {
48333       {
48334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48335       };
48336     } catch (Dali::DaliException e) {
48337       {
48338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48339       };
48340     } catch (...) {
48341       {
48342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48343       };
48344     }
48345   }
48346
48347 }
48348
48349
48350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48351   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48352   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48353   Dali::Vector< int >::ItemType *arg3 = 0 ;
48354   Dali::Vector< int >::ItemType temp3 ;
48355
48356   arg1 = (Dali::Vector< int > *)jarg1;
48357   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48358   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48359   arg3 = &temp3;
48360   {
48361     try {
48362       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48363     } catch (std::out_of_range& e) {
48364       {
48365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48366       };
48367     } catch (std::exception& e) {
48368       {
48369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48370       };
48371     } catch (Dali::DaliException e) {
48372       {
48373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48374       };
48375     } catch (...) {
48376       {
48377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48378       };
48379     }
48380   }
48381
48382 }
48383
48384
48385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48386   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48387   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48388   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48389   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48390
48391   arg1 = (Dali::Vector< int > *)jarg1;
48392   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48393   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48394   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48395   {
48396     try {
48397       (arg1)->Insert(arg2,arg3,arg4);
48398     } catch (std::out_of_range& e) {
48399       {
48400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48401       };
48402     } catch (std::exception& e) {
48403       {
48404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48405       };
48406     } catch (Dali::DaliException e) {
48407       {
48408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48409       };
48410     } catch (...) {
48411       {
48412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48413       };
48414     }
48415   }
48416
48417 }
48418
48419
48420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48421   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48422   Dali::Vector< int >::SizeType arg2 ;
48423
48424   arg1 = (Dali::Vector< int > *)jarg1;
48425   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48426   {
48427     try {
48428       (arg1)->Reserve(arg2);
48429     } catch (std::out_of_range& e) {
48430       {
48431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48432       };
48433     } catch (std::exception& e) {
48434       {
48435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48436       };
48437     } catch (Dali::DaliException e) {
48438       {
48439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48440       };
48441     } catch (...) {
48442       {
48443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48444       };
48445     }
48446   }
48447
48448 }
48449
48450
48451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48452   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48453   Dali::Vector< int >::SizeType arg2 ;
48454
48455   arg1 = (Dali::Vector< int > *)jarg1;
48456   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48457   {
48458     try {
48459       (arg1)->Resize(arg2);
48460     } catch (std::out_of_range& e) {
48461       {
48462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48463       };
48464     } catch (std::exception& e) {
48465       {
48466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48467       };
48468     } catch (Dali::DaliException e) {
48469       {
48470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48471       };
48472     } catch (...) {
48473       {
48474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48475       };
48476     }
48477   }
48478
48479 }
48480
48481
48482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48483   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48484   Dali::Vector< int >::SizeType arg2 ;
48485   Dali::Vector< int >::ItemType *arg3 = 0 ;
48486   Dali::Vector< int >::ItemType temp3 ;
48487
48488   arg1 = (Dali::Vector< int > *)jarg1;
48489   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48490   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48491   arg3 = &temp3;
48492   {
48493     try {
48494       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48495     } catch (std::out_of_range& e) {
48496       {
48497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48498       };
48499     } catch (std::exception& e) {
48500       {
48501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48502       };
48503     } catch (Dali::DaliException e) {
48504       {
48505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48506       };
48507     } catch (...) {
48508       {
48509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48510       };
48511     }
48512   }
48513
48514 }
48515
48516
48517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48518   void * jresult ;
48519   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48520   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48521   Dali::Vector< int >::Iterator result;
48522
48523   arg1 = (Dali::Vector< int > *)jarg1;
48524   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48525   {
48526     try {
48527       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48528     } catch (std::out_of_range& e) {
48529       {
48530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48531       };
48532     } catch (std::exception& e) {
48533       {
48534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48535       };
48536     } catch (Dali::DaliException e) {
48537       {
48538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48539       };
48540     } catch (...) {
48541       {
48542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48543       };
48544     }
48545   }
48546
48547   jresult = (void *)result;
48548   return jresult;
48549 }
48550
48551
48552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48553   void * jresult ;
48554   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48555   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48556   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48557   Dali::Vector< int >::Iterator result;
48558
48559   arg1 = (Dali::Vector< int > *)jarg1;
48560   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48561   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48562   {
48563     try {
48564       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48565     } catch (std::out_of_range& e) {
48566       {
48567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48568       };
48569     } catch (std::exception& e) {
48570       {
48571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48572       };
48573     } catch (Dali::DaliException e) {
48574       {
48575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48576       };
48577     } catch (...) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48580       };
48581     }
48582   }
48583
48584   jresult = (void *)result;
48585   return jresult;
48586 }
48587
48588
48589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48590   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48591   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48592
48593   arg1 = (Dali::Vector< int > *)jarg1;
48594   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48595   {
48596     try {
48597       (arg1)->Remove(arg2);
48598     } catch (std::out_of_range& e) {
48599       {
48600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48601       };
48602     } catch (std::exception& e) {
48603       {
48604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48605       };
48606     } catch (Dali::DaliException e) {
48607       {
48608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48609       };
48610     } catch (...) {
48611       {
48612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48613       };
48614     }
48615   }
48616
48617 }
48618
48619
48620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48621   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48622   Dali::Vector< int > *arg2 = 0 ;
48623
48624   arg1 = (Dali::Vector< int > *)jarg1;
48625   arg2 = (Dali::Vector< int > *)jarg2;
48626   if (!arg2) {
48627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48628     return ;
48629   }
48630   {
48631     try {
48632       (arg1)->Swap(*arg2);
48633     } catch (std::out_of_range& e) {
48634       {
48635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48636       };
48637     } catch (std::exception& e) {
48638       {
48639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48640       };
48641     } catch (Dali::DaliException e) {
48642       {
48643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48644       };
48645     } catch (...) {
48646       {
48647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48648       };
48649     }
48650   }
48651
48652 }
48653
48654
48655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48656   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48657
48658   arg1 = (Dali::Vector< int > *)jarg1;
48659   {
48660     try {
48661       (arg1)->Clear();
48662     } catch (std::out_of_range& e) {
48663       {
48664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48665       };
48666     } catch (std::exception& e) {
48667       {
48668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48669       };
48670     } catch (Dali::DaliException e) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48673       };
48674     } catch (...) {
48675       {
48676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48677       };
48678     }
48679   }
48680
48681 }
48682
48683
48684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48685   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48686
48687   arg1 = (Dali::Vector< int > *)jarg1;
48688   {
48689     try {
48690       (arg1)->Release();
48691     } catch (std::out_of_range& e) {
48692       {
48693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48694       };
48695     } catch (std::exception& e) {
48696       {
48697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48698       };
48699     } catch (Dali::DaliException e) {
48700       {
48701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48702       };
48703     } catch (...) {
48704       {
48705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48706       };
48707     }
48708   }
48709
48710 }
48711
48712
48713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48714   int jresult ;
48715   int result;
48716
48717   result = (int)Dali::Vector< float >::BaseType;
48718   jresult = (int)result;
48719   return jresult;
48720 }
48721
48722
48723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48724   void * jresult ;
48725   Dali::Vector< float > *result = 0 ;
48726
48727   {
48728     try {
48729       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48730     } catch (std::out_of_range& e) {
48731       {
48732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48733       };
48734     } catch (std::exception& e) {
48735       {
48736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48737       };
48738     } catch (Dali::DaliException e) {
48739       {
48740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48741       };
48742     } catch (...) {
48743       {
48744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48745       };
48746     }
48747   }
48748
48749   jresult = (void *)result;
48750   return jresult;
48751 }
48752
48753
48754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48755   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48756
48757   arg1 = (Dali::Vector< float > *)jarg1;
48758   {
48759     try {
48760       delete arg1;
48761     } catch (std::out_of_range& e) {
48762       {
48763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48764       };
48765     } catch (std::exception& e) {
48766       {
48767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48768       };
48769     } catch (Dali::DaliException e) {
48770       {
48771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48772       };
48773     } catch (...) {
48774       {
48775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48776       };
48777     }
48778   }
48779
48780 }
48781
48782
48783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48784   void * jresult ;
48785   Dali::Vector< float > *arg1 = 0 ;
48786   Dali::Vector< float > *result = 0 ;
48787
48788   arg1 = (Dali::Vector< float > *)jarg1;
48789   if (!arg1) {
48790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48791     return 0;
48792   }
48793   {
48794     try {
48795       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48796     } catch (std::out_of_range& e) {
48797       {
48798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48799       };
48800     } catch (std::exception& e) {
48801       {
48802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48803       };
48804     } catch (Dali::DaliException e) {
48805       {
48806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48807       };
48808     } catch (...) {
48809       {
48810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48811       };
48812     }
48813   }
48814
48815   jresult = (void *)result;
48816   return jresult;
48817 }
48818
48819
48820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48821   void * jresult ;
48822   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48823   Dali::Vector< float > *arg2 = 0 ;
48824   Dali::Vector< float > *result = 0 ;
48825
48826   arg1 = (Dali::Vector< float > *)jarg1;
48827   arg2 = (Dali::Vector< float > *)jarg2;
48828   if (!arg2) {
48829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48830     return 0;
48831   }
48832   {
48833     try {
48834       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (Dali::DaliException e) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48846       };
48847     } catch (...) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48850       };
48851     }
48852   }
48853
48854   jresult = (void *)result;
48855   return jresult;
48856 }
48857
48858
48859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48860   void * jresult ;
48861   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48862   Dali::Vector< float >::Iterator result;
48863
48864   arg1 = (Dali::Vector< float > *)jarg1;
48865   {
48866     try {
48867       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48868     } catch (std::out_of_range& e) {
48869       {
48870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48871       };
48872     } catch (std::exception& e) {
48873       {
48874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (Dali::DaliException e) {
48877       {
48878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48879       };
48880     } catch (...) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48883       };
48884     }
48885   }
48886
48887   jresult = (void *)result;
48888   return jresult;
48889 }
48890
48891
48892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48893   void * jresult ;
48894   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48895   Dali::Vector< float >::Iterator result;
48896
48897   arg1 = (Dali::Vector< float > *)jarg1;
48898   {
48899     try {
48900       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48901     } catch (std::out_of_range& e) {
48902       {
48903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48904       };
48905     } catch (std::exception& e) {
48906       {
48907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48908       };
48909     } catch (Dali::DaliException e) {
48910       {
48911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48912       };
48913     } catch (...) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48916       };
48917     }
48918   }
48919
48920   jresult = (void *)result;
48921   return jresult;
48922 }
48923
48924
48925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48926   void * jresult ;
48927   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48928   Dali::Vector< float >::SizeType arg2 ;
48929   Dali::Vector< float >::ItemType *result = 0 ;
48930
48931   arg1 = (Dali::Vector< float > *)jarg1;
48932   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48933   {
48934     try {
48935       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48936     } catch (std::out_of_range& e) {
48937       {
48938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48939       };
48940     } catch (std::exception& e) {
48941       {
48942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48943       };
48944     } catch (Dali::DaliException e) {
48945       {
48946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48947       };
48948     } catch (...) {
48949       {
48950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48951       };
48952     }
48953   }
48954
48955   jresult = (void *)result;
48956   return jresult;
48957 }
48958
48959
48960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48961   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48962   Dali::Vector< float >::ItemType *arg2 = 0 ;
48963   Dali::Vector< float >::ItemType temp2 ;
48964
48965   arg1 = (Dali::Vector< float > *)jarg1;
48966   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48967   arg2 = &temp2;
48968   {
48969     try {
48970       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48971     } catch (std::out_of_range& e) {
48972       {
48973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48974       };
48975     } catch (std::exception& e) {
48976       {
48977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48978       };
48979     } catch (Dali::DaliException e) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48982       };
48983     } catch (...) {
48984       {
48985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48986       };
48987     }
48988   }
48989
48990 }
48991
48992
48993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48994   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48995   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48996   Dali::Vector< float >::ItemType *arg3 = 0 ;
48997   Dali::Vector< float >::ItemType temp3 ;
48998
48999   arg1 = (Dali::Vector< float > *)jarg1;
49000   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49001   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49002   arg3 = &temp3;
49003   {
49004     try {
49005       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49006     } catch (std::out_of_range& e) {
49007       {
49008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49009       };
49010     } catch (std::exception& e) {
49011       {
49012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49013       };
49014     } catch (Dali::DaliException e) {
49015       {
49016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49017       };
49018     } catch (...) {
49019       {
49020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49021       };
49022     }
49023   }
49024
49025 }
49026
49027
49028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49029   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49030   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49031   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49032   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
49033
49034   arg1 = (Dali::Vector< float > *)jarg1;
49035   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49036   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49037   arg4 = (Dali::Vector< float >::Iterator)jarg4;
49038   {
49039     try {
49040       (arg1)->Insert(arg2,arg3,arg4);
49041     } catch (std::out_of_range& e) {
49042       {
49043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49044       };
49045     } catch (std::exception& e) {
49046       {
49047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49048       };
49049     } catch (Dali::DaliException e) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49052       };
49053     } catch (...) {
49054       {
49055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49056       };
49057     }
49058   }
49059
49060 }
49061
49062
49063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
49064   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49065   Dali::Vector< float >::SizeType arg2 ;
49066
49067   arg1 = (Dali::Vector< float > *)jarg1;
49068   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49069   {
49070     try {
49071       (arg1)->Reserve(arg2);
49072     } catch (std::out_of_range& e) {
49073       {
49074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49075       };
49076     } catch (std::exception& e) {
49077       {
49078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49079       };
49080     } catch (Dali::DaliException e) {
49081       {
49082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49087       };
49088     }
49089   }
49090
49091 }
49092
49093 //// ========================= end of part 2 =============================
49094
49095 //// ========================== start part 3 ===============================
49096
49097
49098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49099   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49100   Dali::Vector< float >::SizeType arg2 ;
49101
49102   arg1 = (Dali::Vector< float > *)jarg1;
49103   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49104   {
49105     try {
49106       (arg1)->Resize(arg2);
49107     } catch (std::out_of_range& e) {
49108       {
49109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49110       };
49111     } catch (std::exception& e) {
49112       {
49113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49114       };
49115     } catch (Dali::DaliException e) {
49116       {
49117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49118       };
49119     } catch (...) {
49120       {
49121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49122       };
49123     }
49124   }
49125
49126 }
49127
49128
49129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
49130   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49131   Dali::Vector< float >::SizeType arg2 ;
49132   Dali::Vector< float >::ItemType *arg3 = 0 ;
49133   Dali::Vector< float >::ItemType temp3 ;
49134
49135   arg1 = (Dali::Vector< float > *)jarg1;
49136   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49137   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49138   arg3 = &temp3;
49139   {
49140     try {
49141       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49142     } catch (std::out_of_range& e) {
49143       {
49144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49145       };
49146     } catch (std::exception& e) {
49147       {
49148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (Dali::DaliException e) {
49151       {
49152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49153       };
49154     } catch (...) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49157       };
49158     }
49159   }
49160
49161 }
49162
49163
49164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
49165   void * jresult ;
49166   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49167   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49168   Dali::Vector< float >::Iterator result;
49169
49170   arg1 = (Dali::Vector< float > *)jarg1;
49171   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49172   {
49173     try {
49174       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
49175     } catch (std::out_of_range& e) {
49176       {
49177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49178       };
49179     } catch (std::exception& e) {
49180       {
49181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49182       };
49183     } catch (Dali::DaliException e) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49186       };
49187     } catch (...) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49190       };
49191     }
49192   }
49193
49194   jresult = (void *)result;
49195   return jresult;
49196 }
49197
49198
49199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49200   void * jresult ;
49201   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49202   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49203   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49204   Dali::Vector< float >::Iterator result;
49205
49206   arg1 = (Dali::Vector< float > *)jarg1;
49207   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49208   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49209   {
49210     try {
49211       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49212     } catch (std::out_of_range& e) {
49213       {
49214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49215       };
49216     } catch (std::exception& e) {
49217       {
49218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49219       };
49220     } catch (Dali::DaliException e) {
49221       {
49222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49227       };
49228     }
49229   }
49230
49231   jresult = (void *)result;
49232   return jresult;
49233 }
49234
49235
49236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49237   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49238   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49239
49240   arg1 = (Dali::Vector< float > *)jarg1;
49241   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49242   {
49243     try {
49244       (arg1)->Remove(arg2);
49245     } catch (std::out_of_range& e) {
49246       {
49247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49248       };
49249     } catch (std::exception& e) {
49250       {
49251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49252       };
49253     } catch (Dali::DaliException e) {
49254       {
49255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49260       };
49261     }
49262   }
49263
49264 }
49265
49266
49267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49268   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49269   Dali::Vector< float > *arg2 = 0 ;
49270
49271   arg1 = (Dali::Vector< float > *)jarg1;
49272   arg2 = (Dali::Vector< float > *)jarg2;
49273   if (!arg2) {
49274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49275     return ;
49276   }
49277   {
49278     try {
49279       (arg1)->Swap(*arg2);
49280     } catch (std::out_of_range& e) {
49281       {
49282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49283       };
49284     } catch (std::exception& e) {
49285       {
49286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49287       };
49288     } catch (Dali::DaliException e) {
49289       {
49290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49291       };
49292     } catch (...) {
49293       {
49294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49295       };
49296     }
49297   }
49298
49299 }
49300
49301
49302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49303   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49304
49305   arg1 = (Dali::Vector< float > *)jarg1;
49306   {
49307     try {
49308       (arg1)->Clear();
49309     } catch (std::out_of_range& e) {
49310       {
49311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49312       };
49313     } catch (std::exception& e) {
49314       {
49315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49316       };
49317     } catch (Dali::DaliException e) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49320       };
49321     } catch (...) {
49322       {
49323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49324       };
49325     }
49326   }
49327
49328 }
49329
49330
49331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49332   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49333
49334   arg1 = (Dali::Vector< float > *)jarg1;
49335   {
49336     try {
49337       (arg1)->Release();
49338     } catch (std::out_of_range& e) {
49339       {
49340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49341       };
49342     } catch (std::exception& e) {
49343       {
49344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49345       };
49346     } catch (Dali::DaliException e) {
49347       {
49348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49349       };
49350     } catch (...) {
49351       {
49352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49353       };
49354     }
49355   }
49356
49357 }
49358
49359
49360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49361   int jresult ;
49362   int result;
49363
49364   result = (int)Dali::Vector< unsigned char >::BaseType;
49365   jresult = (int)result;
49366   return jresult;
49367 }
49368
49369
49370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49371   void * jresult ;
49372   Dali::Vector< unsigned char > *result = 0 ;
49373
49374   {
49375     try {
49376       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49377     } catch (std::out_of_range& e) {
49378       {
49379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49380       };
49381     } catch (std::exception& e) {
49382       {
49383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49384       };
49385     } catch (Dali::DaliException e) {
49386       {
49387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49388       };
49389     } catch (...) {
49390       {
49391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49392       };
49393     }
49394   }
49395
49396   jresult = (void *)result;
49397   return jresult;
49398 }
49399
49400
49401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49402   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49403
49404   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49405   {
49406     try {
49407       delete arg1;
49408     } catch (std::out_of_range& e) {
49409       {
49410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49411       };
49412     } catch (std::exception& e) {
49413       {
49414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49415       };
49416     } catch (Dali::DaliException e) {
49417       {
49418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49419       };
49420     } catch (...) {
49421       {
49422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49423       };
49424     }
49425   }
49426
49427 }
49428
49429
49430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49431   void * jresult ;
49432   Dali::Vector< unsigned char > *arg1 = 0 ;
49433   Dali::Vector< unsigned char > *result = 0 ;
49434
49435   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49436   if (!arg1) {
49437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49438     return 0;
49439   }
49440   {
49441     try {
49442       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
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 (Dali::DaliException e) {
49452       {
49453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49454       };
49455     } catch (...) {
49456       {
49457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49458       };
49459     }
49460   }
49461
49462   jresult = (void *)result;
49463   return jresult;
49464 }
49465
49466
49467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49468   void * jresult ;
49469   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49470   Dali::Vector< unsigned char > *arg2 = 0 ;
49471   Dali::Vector< unsigned char > *result = 0 ;
49472
49473   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49474   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49475   if (!arg2) {
49476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49477     return 0;
49478   }
49479   {
49480     try {
49481       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49482     } catch (std::out_of_range& e) {
49483       {
49484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49485       };
49486     } catch (std::exception& e) {
49487       {
49488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49489       };
49490     } catch (Dali::DaliException e) {
49491       {
49492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49493       };
49494     } catch (...) {
49495       {
49496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49497       };
49498     }
49499   }
49500
49501   jresult = (void *)result;
49502   return jresult;
49503 }
49504
49505
49506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49507   void * jresult ;
49508   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49509   Dali::Vector< unsigned char >::Iterator result;
49510
49511   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49512   {
49513     try {
49514       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49515     } catch (std::out_of_range& e) {
49516       {
49517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49518       };
49519     } catch (std::exception& e) {
49520       {
49521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49522       };
49523     } catch (Dali::DaliException e) {
49524       {
49525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49530       };
49531     }
49532   }
49533
49534   jresult = (void *)result;
49535   return jresult;
49536 }
49537
49538
49539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49540   void * jresult ;
49541   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49542   Dali::Vector< unsigned char >::Iterator result;
49543
49544   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49545   {
49546     try {
49547       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49548     } catch (std::out_of_range& e) {
49549       {
49550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49551       };
49552     } catch (std::exception& e) {
49553       {
49554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49555       };
49556     } catch (Dali::DaliException e) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49559       };
49560     } catch (...) {
49561       {
49562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49563       };
49564     }
49565   }
49566
49567   jresult = (void *)result;
49568   return jresult;
49569 }
49570
49571
49572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49573   void * jresult ;
49574   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49575   Dali::Vector< unsigned char >::SizeType arg2 ;
49576   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49577
49578   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49579   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49580   {
49581     try {
49582       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49583     } catch (std::out_of_range& e) {
49584       {
49585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49586       };
49587     } catch (std::exception& e) {
49588       {
49589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (Dali::DaliException e) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49594       };
49595     } catch (...) {
49596       {
49597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49598       };
49599     }
49600   }
49601
49602   jresult = (void *)result;
49603   return jresult;
49604 }
49605
49606
49607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49608   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49609   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49610   Dali::Vector< unsigned char >::ItemType temp2 ;
49611
49612   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49613   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49614   arg2 = &temp2;
49615   {
49616     try {
49617       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49625       };
49626     } catch (Dali::DaliException e) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49629       };
49630     } catch (...) {
49631       {
49632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49633       };
49634     }
49635   }
49636
49637 }
49638
49639
49640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49641   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49642   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49643   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49644   Dali::Vector< unsigned char >::ItemType temp3 ;
49645
49646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49647   arg2 = jarg2;
49648   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49649   arg3 = &temp3;
49650   {
49651     try {
49652       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49653     } catch (std::out_of_range& e) {
49654       {
49655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49656       };
49657     } catch (std::exception& e) {
49658       {
49659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49660       };
49661     } catch (Dali::DaliException e) {
49662       {
49663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49664       };
49665     } catch (...) {
49666       {
49667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49668       };
49669     }
49670   }
49671
49672
49673
49674 }
49675
49676
49677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49678   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49679   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49680   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49681   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49682
49683   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49684   arg2 = jarg2;
49685   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49686   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49687   {
49688     try {
49689       (arg1)->Insert(arg2,arg3,arg4);
49690     } catch (std::out_of_range& e) {
49691       {
49692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49693       };
49694     } catch (std::exception& e) {
49695       {
49696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49697       };
49698     } catch (Dali::DaliException e) {
49699       {
49700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49701       };
49702     } catch (...) {
49703       {
49704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49705       };
49706     }
49707   }
49708
49709
49710
49711 }
49712
49713
49714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49715   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49716   Dali::Vector< unsigned char >::SizeType arg2 ;
49717
49718   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49719   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49720   {
49721     try {
49722       (arg1)->Reserve(arg2);
49723     } catch (std::out_of_range& e) {
49724       {
49725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49726       };
49727     } catch (std::exception& e) {
49728       {
49729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49730       };
49731     } catch (Dali::DaliException e) {
49732       {
49733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49734       };
49735     } catch (...) {
49736       {
49737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49738       };
49739     }
49740   }
49741
49742 }
49743
49744
49745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49746   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49747   Dali::Vector< unsigned char >::SizeType arg2 ;
49748
49749   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49750   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49751   {
49752     try {
49753       (arg1)->Resize(arg2);
49754     } catch (std::out_of_range& e) {
49755       {
49756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49757       };
49758     } catch (std::exception& e) {
49759       {
49760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49761       };
49762     } catch (Dali::DaliException e) {
49763       {
49764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49765       };
49766     } catch (...) {
49767       {
49768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49769       };
49770     }
49771   }
49772
49773 }
49774
49775
49776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49777   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49778   Dali::Vector< unsigned char >::SizeType arg2 ;
49779   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49780   Dali::Vector< unsigned char >::ItemType temp3 ;
49781
49782   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49783   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49784   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49785   arg3 = &temp3;
49786   {
49787     try {
49788       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49796       };
49797     } catch (Dali::DaliException e) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49800       };
49801     } catch (...) {
49802       {
49803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49804       };
49805     }
49806   }
49807
49808 }
49809
49810
49811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49812   void * jresult ;
49813   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49814   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49815   Dali::Vector< unsigned char >::Iterator result;
49816
49817   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49818   arg2 = jarg2;
49819   {
49820     try {
49821       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49822     } catch (std::out_of_range& e) {
49823       {
49824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49825       };
49826     } catch (std::exception& e) {
49827       {
49828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49829       };
49830     } catch (Dali::DaliException e) {
49831       {
49832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49833       };
49834     } catch (...) {
49835       {
49836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49837       };
49838     }
49839   }
49840
49841   jresult = (void *)result;
49842
49843
49844   return jresult;
49845 }
49846
49847
49848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49849   void * jresult ;
49850   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49851   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49852   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49853   Dali::Vector< unsigned char >::Iterator result;
49854
49855   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49856   arg2 = jarg2;
49857   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49858   {
49859     try {
49860       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49861     } catch (std::out_of_range& e) {
49862       {
49863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49864       };
49865     } catch (std::exception& e) {
49866       {
49867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49868       };
49869     } catch (Dali::DaliException e) {
49870       {
49871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49872       };
49873     } catch (...) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49876       };
49877     }
49878   }
49879
49880   jresult = (void *)result;
49881
49882
49883   return jresult;
49884 }
49885
49886
49887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49888   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49889   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49890
49891   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49892   arg2 = jarg2;
49893   {
49894     try {
49895       (arg1)->Remove(arg2);
49896     } catch (std::out_of_range& e) {
49897       {
49898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49899       };
49900     } catch (std::exception& e) {
49901       {
49902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49903       };
49904     } catch (Dali::DaliException e) {
49905       {
49906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49907       };
49908     } catch (...) {
49909       {
49910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49911       };
49912     }
49913   }
49914
49915
49916
49917 }
49918
49919
49920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49921   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49922   Dali::Vector< unsigned char > *arg2 = 0 ;
49923
49924   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49925   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49926   if (!arg2) {
49927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49928     return ;
49929   }
49930   {
49931     try {
49932       (arg1)->Swap(*arg2);
49933     } catch (std::out_of_range& e) {
49934       {
49935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49936       };
49937     } catch (std::exception& e) {
49938       {
49939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49940       };
49941     } catch (Dali::DaliException e) {
49942       {
49943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49944       };
49945     } catch (...) {
49946       {
49947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49948       };
49949     }
49950   }
49951
49952 }
49953
49954
49955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49956   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49957
49958   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49959   {
49960     try {
49961       (arg1)->Clear();
49962     } catch (std::out_of_range& e) {
49963       {
49964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (std::exception& e) {
49967       {
49968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49969       };
49970     } catch (Dali::DaliException e) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49973       };
49974     } catch (...) {
49975       {
49976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49977       };
49978     }
49979   }
49980
49981 }
49982
49983
49984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49985   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49986
49987   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49988   {
49989     try {
49990       (arg1)->Release();
49991     } catch (std::out_of_range& e) {
49992       {
49993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49994       };
49995     } catch (std::exception& e) {
49996       {
49997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49998       };
49999     } catch (Dali::DaliException e) {
50000       {
50001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50006       };
50007     }
50008   }
50009
50010 }
50011
50012
50013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
50014   int jresult ;
50015   int result;
50016
50017   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
50018   jresult = (int)result;
50019   return jresult;
50020 }
50021
50022
50023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
50024   void * jresult ;
50025   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50026
50027   {
50028     try {
50029       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
50030     } catch (std::out_of_range& e) {
50031       {
50032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50033       };
50034     } catch (std::exception& e) {
50035       {
50036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50037       };
50038     } catch (Dali::DaliException e) {
50039       {
50040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50041       };
50042     } catch (...) {
50043       {
50044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50045       };
50046     }
50047   }
50048
50049   jresult = (void *)result;
50050   return jresult;
50051 }
50052
50053
50054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
50055   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50056
50057   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50058   {
50059     try {
50060       delete arg1;
50061     } catch (std::out_of_range& e) {
50062       {
50063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50064       };
50065     } catch (std::exception& e) {
50066       {
50067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50068       };
50069     } catch (Dali::DaliException e) {
50070       {
50071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50072       };
50073     } catch (...) {
50074       {
50075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50076       };
50077     }
50078   }
50079
50080 }
50081
50082
50083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
50084   void * jresult ;
50085   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
50086   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50087
50088   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50089   if (!arg1) {
50090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50091     return 0;
50092   }
50093   {
50094     try {
50095       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
50096     } catch (std::out_of_range& e) {
50097       {
50098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50099       };
50100     } catch (std::exception& e) {
50101       {
50102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50103       };
50104     } catch (Dali::DaliException e) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50107       };
50108     } catch (...) {
50109       {
50110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50111       };
50112     }
50113   }
50114
50115   jresult = (void *)result;
50116   return jresult;
50117 }
50118
50119
50120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
50121   void * jresult ;
50122   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50123   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50124   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50125
50126   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50127   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50128   if (!arg2) {
50129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50130     return 0;
50131   }
50132   {
50133     try {
50134       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
50135     } catch (std::out_of_range& e) {
50136       {
50137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50138       };
50139     } catch (std::exception& e) {
50140       {
50141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (Dali::DaliException e) {
50144       {
50145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50146       };
50147     } catch (...) {
50148       {
50149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50150       };
50151     }
50152   }
50153
50154   jresult = (void *)result;
50155   return jresult;
50156 }
50157
50158
50159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
50160   void * jresult ;
50161   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50162   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50163
50164   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50165   {
50166     try {
50167       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
50168     } catch (std::out_of_range& e) {
50169       {
50170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50171       };
50172     } catch (std::exception& e) {
50173       {
50174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50175       };
50176     } catch (Dali::DaliException e) {
50177       {
50178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50179       };
50180     } catch (...) {
50181       {
50182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50183       };
50184     }
50185   }
50186
50187   jresult = (void *)result;
50188   return jresult;
50189 }
50190
50191
50192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50193   void * jresult ;
50194   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50195   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50196
50197   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50198   {
50199     try {
50200       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50201     } catch (std::out_of_range& e) {
50202       {
50203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50204       };
50205     } catch (std::exception& e) {
50206       {
50207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (Dali::DaliException e) {
50210       {
50211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50212       };
50213     } catch (...) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50216       };
50217     }
50218   }
50219
50220   jresult = (void *)result;
50221   return jresult;
50222 }
50223
50224
50225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50226   void * jresult ;
50227   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50228   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50229   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50230
50231   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50232   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50233   {
50234     try {
50235       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50236     } catch (std::out_of_range& e) {
50237       {
50238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50239       };
50240     } catch (std::exception& e) {
50241       {
50242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50243       };
50244     } catch (Dali::DaliException e) {
50245       {
50246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50247       };
50248     } catch (...) {
50249       {
50250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50251       };
50252     }
50253   }
50254
50255   jresult = (void *)result;
50256   return jresult;
50257 }
50258
50259
50260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50261   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50262   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50263
50264   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50265   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50266   if (!arg2) {
50267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50268     return ;
50269   }
50270   {
50271     try {
50272       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50273     } catch (std::out_of_range& e) {
50274       {
50275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50276       };
50277     } catch (std::exception& e) {
50278       {
50279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50280       };
50281     } catch (Dali::DaliException e) {
50282       {
50283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50284       };
50285     } catch (...) {
50286       {
50287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50288       };
50289     }
50290   }
50291
50292 }
50293
50294
50295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50296   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50297   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50298   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50299
50300   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50301   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50302   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50303   if (!arg3) {
50304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50305     return ;
50306   }
50307   {
50308     try {
50309       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50310     } catch (std::out_of_range& e) {
50311       {
50312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50313       };
50314     } catch (std::exception& e) {
50315       {
50316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50317       };
50318     } catch (Dali::DaliException e) {
50319       {
50320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50321       };
50322     } catch (...) {
50323       {
50324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50325       };
50326     }
50327   }
50328
50329 }
50330
50331
50332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50333   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50334   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50335   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50336   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50337
50338   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50339   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50340   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50341   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50342   {
50343     try {
50344       (arg1)->Insert(arg2,arg3,arg4);
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 (Dali::DaliException e) {
50354       {
50355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50356       };
50357     } catch (...) {
50358       {
50359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50360       };
50361     }
50362   }
50363
50364 }
50365
50366
50367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50368   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50369   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50370
50371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50372   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50373   {
50374     try {
50375       (arg1)->Reserve(arg2);
50376     } catch (std::out_of_range& e) {
50377       {
50378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50379       };
50380     } catch (std::exception& e) {
50381       {
50382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50383       };
50384     } catch (Dali::DaliException e) {
50385       {
50386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50387       };
50388     } catch (...) {
50389       {
50390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50391       };
50392     }
50393   }
50394
50395 }
50396
50397
50398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50399   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50400   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50401
50402   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50403   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50404   {
50405     try {
50406       (arg1)->Resize(arg2);
50407     } catch (std::out_of_range& e) {
50408       {
50409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50410       };
50411     } catch (std::exception& e) {
50412       {
50413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50414       };
50415     } catch (Dali::DaliException e) {
50416       {
50417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50418       };
50419     } catch (...) {
50420       {
50421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50422       };
50423     }
50424   }
50425
50426 }
50427
50428
50429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50430   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50431   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50432   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50433
50434   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50435   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50436   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50437   if (!arg3) {
50438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50439     return ;
50440   }
50441   {
50442     try {
50443       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50444     } catch (std::out_of_range& e) {
50445       {
50446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50447       };
50448     } catch (std::exception& e) {
50449       {
50450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50451       };
50452     } catch (Dali::DaliException e) {
50453       {
50454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50455       };
50456     } catch (...) {
50457       {
50458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50459       };
50460     }
50461   }
50462
50463 }
50464
50465
50466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50467   void * jresult ;
50468   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50469   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50470   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50471
50472   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50473   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50474   {
50475     try {
50476       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50477     } catch (std::out_of_range& e) {
50478       {
50479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50480       };
50481     } catch (std::exception& e) {
50482       {
50483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50484       };
50485     } catch (Dali::DaliException e) {
50486       {
50487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50488       };
50489     } catch (...) {
50490       {
50491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50492       };
50493     }
50494   }
50495
50496   jresult = (void *)result;
50497   return jresult;
50498 }
50499
50500
50501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50502   void * jresult ;
50503   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50504   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50505   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50506   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50507
50508   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50509   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50510   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50511   {
50512     try {
50513       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50514     } catch (std::out_of_range& e) {
50515       {
50516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50517       };
50518     } catch (std::exception& e) {
50519       {
50520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50521       };
50522     } catch (Dali::DaliException e) {
50523       {
50524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50525       };
50526     } catch (...) {
50527       {
50528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50529       };
50530     }
50531   }
50532
50533   jresult = (void *)result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50540   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50541
50542   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50543   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50544   {
50545     try {
50546       (arg1)->Remove(arg2);
50547     } catch (std::out_of_range& e) {
50548       {
50549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50550       };
50551     } catch (std::exception& e) {
50552       {
50553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50554       };
50555     } catch (Dali::DaliException e) {
50556       {
50557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50558       };
50559     } catch (...) {
50560       {
50561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50562       };
50563     }
50564   }
50565
50566 }
50567
50568
50569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50570   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50571   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50572
50573   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50574   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50575   if (!arg2) {
50576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50577     return ;
50578   }
50579   {
50580     try {
50581       (arg1)->Swap(*arg2);
50582     } catch (std::out_of_range& e) {
50583       {
50584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50585       };
50586     } catch (std::exception& e) {
50587       {
50588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50589       };
50590     } catch (Dali::DaliException e) {
50591       {
50592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50593       };
50594     } catch (...) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50597       };
50598     }
50599   }
50600
50601 }
50602
50603
50604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50605   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50606
50607   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50608   {
50609     try {
50610       (arg1)->Clear();
50611     } catch (std::out_of_range& e) {
50612       {
50613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50614       };
50615     } catch (std::exception& e) {
50616       {
50617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50618       };
50619     } catch (Dali::DaliException e) {
50620       {
50621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50622       };
50623     } catch (...) {
50624       {
50625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50626       };
50627     }
50628   }
50629
50630 }
50631
50632
50633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50634   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50635
50636   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50637   {
50638     try {
50639       (arg1)->Release();
50640     } catch (std::out_of_range& e) {
50641       {
50642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50643       };
50644     } catch (std::exception& e) {
50645       {
50646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50647       };
50648     } catch (Dali::DaliException e) {
50649       {
50650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50651       };
50652     } catch (...) {
50653       {
50654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50655       };
50656     }
50657   }
50658
50659 }
50660
50661
50662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50663   void * jresult ;
50664   Dali::Signal< void () > *result = 0 ;
50665
50666   {
50667     try {
50668       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50669     } catch (std::out_of_range& e) {
50670       {
50671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50672       };
50673     } catch (std::exception& e) {
50674       {
50675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50676       };
50677     } catch (Dali::DaliException e) {
50678       {
50679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50680       };
50681     } catch (...) {
50682       {
50683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50684       };
50685     }
50686   }
50687
50688   jresult = (void *)result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50694   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50695
50696   arg1 = (Dali::Signal< void () > *)jarg1;
50697   {
50698     try {
50699       delete arg1;
50700     } catch (std::out_of_range& e) {
50701       {
50702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50703       };
50704     } catch (std::exception& e) {
50705       {
50706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50707       };
50708     } catch (Dali::DaliException e) {
50709       {
50710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50711       };
50712     } catch (...) {
50713       {
50714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50715       };
50716     }
50717   }
50718
50719 }
50720
50721
50722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50723   unsigned int jresult ;
50724   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50725   bool result;
50726
50727   arg1 = (Dali::Signal< void () > *)jarg1;
50728   {
50729     try {
50730       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50731     } catch (std::out_of_range& e) {
50732       {
50733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50734       };
50735     } catch (std::exception& e) {
50736       {
50737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50738       };
50739     } catch (Dali::DaliException e) {
50740       {
50741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50742       };
50743     } catch (...) {
50744       {
50745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50746       };
50747     }
50748   }
50749
50750   jresult = result;
50751   return jresult;
50752 }
50753
50754
50755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50756   unsigned long jresult ;
50757   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50758   std::size_t result;
50759
50760   arg1 = (Dali::Signal< void () > *)jarg1;
50761   {
50762     try {
50763       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50764     } catch (std::out_of_range& e) {
50765       {
50766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50767       };
50768     } catch (std::exception& e) {
50769       {
50770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50771       };
50772     } catch (Dali::DaliException e) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50775       };
50776     } catch (...) {
50777       {
50778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50779       };
50780     }
50781   }
50782
50783   jresult = (unsigned long)result;
50784   return jresult;
50785 }
50786
50787
50788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50789   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50790   void (*arg2)() = (void (*)()) 0 ;
50791
50792   arg1 = (Dali::Signal< void () > *)jarg1;
50793   arg2 = (void (*)())jarg2;
50794   {
50795     try {
50796       (arg1)->Connect(arg2);
50797     } catch (std::out_of_range& e) {
50798       {
50799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50800       };
50801     } catch (std::exception& e) {
50802       {
50803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50804       };
50805     } catch (Dali::DaliException e) {
50806       {
50807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50808       };
50809     } catch (...) {
50810       {
50811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50812       };
50813     }
50814   }
50815
50816 }
50817
50818
50819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50820   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50821   void (*arg2)() = (void (*)()) 0 ;
50822
50823   arg1 = (Dali::Signal< void () > *)jarg1;
50824   arg2 = (void (*)())jarg2;
50825   {
50826     try {
50827       (arg1)->Disconnect(arg2);
50828     } catch (std::out_of_range& e) {
50829       {
50830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50831       };
50832     } catch (std::exception& e) {
50833       {
50834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50835       };
50836     } catch (Dali::DaliException e) {
50837       {
50838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50839       };
50840     } catch (...) {
50841       {
50842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50843       };
50844     }
50845   }
50846
50847 }
50848
50849
50850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50851   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50852   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50853   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50854
50855   arg1 = (Dali::Signal< void () > *)jarg1;
50856   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50857   arg3 = (Dali::FunctorDelegate *)jarg3;
50858   {
50859     try {
50860       (arg1)->Connect(arg2,arg3);
50861     } catch (std::out_of_range& e) {
50862       {
50863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50864       };
50865     } catch (std::exception& e) {
50866       {
50867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50868       };
50869     } catch (Dali::DaliException e) {
50870       {
50871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50872       };
50873     } catch (...) {
50874       {
50875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50876       };
50877     }
50878   }
50879
50880 }
50881
50882
50883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50884   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50885
50886   arg1 = (Dali::Signal< void () > *)jarg1;
50887   {
50888     try {
50889       (arg1)->Emit();
50890     } catch (std::out_of_range& e) {
50891       {
50892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50893       };
50894     } catch (std::exception& e) {
50895       {
50896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50897       };
50898     } catch (Dali::DaliException e) {
50899       {
50900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50901       };
50902     } catch (...) {
50903       {
50904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50905       };
50906     }
50907   }
50908
50909 }
50910
50911
50912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50913   unsigned int jresult ;
50914   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50915   bool result;
50916
50917   arg1 = (Dali::Signal< void (float) > *)jarg1;
50918   {
50919     try {
50920       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50928       };
50929     } catch (Dali::DaliException e) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50936       };
50937     }
50938   }
50939
50940   jresult = result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50946   unsigned long jresult ;
50947   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50948   std::size_t result;
50949
50950   arg1 = (Dali::Signal< void (float) > *)jarg1;
50951   {
50952     try {
50953       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50954     } catch (std::out_of_range& e) {
50955       {
50956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50957       };
50958     } catch (std::exception& e) {
50959       {
50960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50961       };
50962     } catch (Dali::DaliException e) {
50963       {
50964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50965       };
50966     } catch (...) {
50967       {
50968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50969       };
50970     }
50971   }
50972
50973   jresult = (unsigned long)result;
50974   return jresult;
50975 }
50976
50977
50978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50979   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50980   void (*arg2)(float) = (void (*)(float)) 0 ;
50981
50982   arg1 = (Dali::Signal< void (float) > *)jarg1;
50983   arg2 = (void (*)(float))jarg2;
50984   {
50985     try {
50986       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50987     } catch (std::out_of_range& e) {
50988       {
50989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50990       };
50991     } catch (std::exception& e) {
50992       {
50993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50994       };
50995     } catch (Dali::DaliException e) {
50996       {
50997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50998       };
50999     } catch (...) {
51000       {
51001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51002       };
51003     }
51004   }
51005
51006 }
51007
51008
51009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
51010   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51011   void (*arg2)(float) = (void (*)(float)) 0 ;
51012
51013   arg1 = (Dali::Signal< void (float) > *)jarg1;
51014   arg2 = (void (*)(float))jarg2;
51015   {
51016     try {
51017       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
51018     } catch (std::out_of_range& e) {
51019       {
51020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51021       };
51022     } catch (std::exception& e) {
51023       {
51024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51025       };
51026     } catch (Dali::DaliException e) {
51027       {
51028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51029       };
51030     } catch (...) {
51031       {
51032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51033       };
51034     }
51035   }
51036
51037 }
51038
51039
51040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
51041   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51042   float arg2 ;
51043
51044   arg1 = (Dali::Signal< void (float) > *)jarg1;
51045   arg2 = (float)jarg2;
51046   {
51047     try {
51048       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
51049     } catch (std::out_of_range& e) {
51050       {
51051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51052       };
51053     } catch (std::exception& e) {
51054       {
51055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51056       };
51057     } catch (Dali::DaliException e) {
51058       {
51059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51060       };
51061     } catch (...) {
51062       {
51063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51064       };
51065     }
51066   }
51067
51068 }
51069
51070
51071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
51072   void * jresult ;
51073   Dali::Signal< void (float) > *result = 0 ;
51074
51075   {
51076     try {
51077       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51085       };
51086     } catch (Dali::DaliException e) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51089       };
51090     } catch (...) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51093       };
51094     }
51095   }
51096
51097   jresult = (void *)result;
51098   return jresult;
51099 }
51100
51101
51102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
51103   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51104
51105   arg1 = (Dali::Signal< void (float) > *)jarg1;
51106   {
51107     try {
51108       delete arg1;
51109     } catch (std::out_of_range& e) {
51110       {
51111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51112       };
51113     } catch (std::exception& e) {
51114       {
51115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51116       };
51117     } catch (Dali::DaliException e) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51124       };
51125     }
51126   }
51127
51128 }
51129
51130
51131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
51132   unsigned int jresult ;
51133   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51134   bool result;
51135
51136   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51137   {
51138     try {
51139       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51140     } catch (std::out_of_range& e) {
51141       {
51142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51143       };
51144     } catch (std::exception& e) {
51145       {
51146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (Dali::DaliException e) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51155       };
51156     }
51157   }
51158
51159   jresult = result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
51165   unsigned long jresult ;
51166   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51167   std::size_t result;
51168
51169   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51170   {
51171     try {
51172       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51173     } catch (std::out_of_range& e) {
51174       {
51175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (std::exception& e) {
51178       {
51179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (Dali::DaliException e) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51184       };
51185     } catch (...) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51188       };
51189     }
51190   }
51191
51192   jresult = (unsigned long)result;
51193   return jresult;
51194 }
51195
51196
51197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51198   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51199   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51200
51201   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51202   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51203   {
51204     try {
51205       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51206     } catch (std::out_of_range& e) {
51207       {
51208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51209       };
51210     } catch (std::exception& e) {
51211       {
51212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51213       };
51214     } catch (Dali::DaliException e) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51217       };
51218     } catch (...) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51221       };
51222     }
51223   }
51224
51225 }
51226
51227
51228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51229   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51230   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51231
51232   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51233   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51234   {
51235     try {
51236       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51237     } catch (std::out_of_range& e) {
51238       {
51239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51240       };
51241     } catch (std::exception& e) {
51242       {
51243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51244       };
51245     } catch (Dali::DaliException e) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51248       };
51249     } catch (...) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51252       };
51253     }
51254   }
51255
51256 }
51257
51258
51259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51260   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51261   Dali::BaseHandle arg2 ;
51262   Dali::BaseHandle *argp2 ;
51263
51264   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51265   argp2 = (Dali::BaseHandle *)jarg2;
51266   if (!argp2) {
51267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51268     return ;
51269   }
51270   arg2 = *argp2;
51271   {
51272     try {
51273       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51274     } catch (std::out_of_range& e) {
51275       {
51276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51277       };
51278     } catch (std::exception& e) {
51279       {
51280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51281       };
51282     } catch (Dali::DaliException e) {
51283       {
51284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51285       };
51286     } catch (...) {
51287       {
51288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51289       };
51290     }
51291   }
51292
51293 }
51294
51295
51296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51297   void * jresult ;
51298   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51299
51300   {
51301     try {
51302       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51303     } catch (std::out_of_range& e) {
51304       {
51305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51306       };
51307     } catch (std::exception& e) {
51308       {
51309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51310       };
51311     } catch (Dali::DaliException e) {
51312       {
51313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51314       };
51315     } catch (...) {
51316       {
51317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51318       };
51319     }
51320   }
51321
51322   jresult = (void *)result;
51323   return jresult;
51324 }
51325
51326
51327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51328   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51329
51330   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51331   {
51332     try {
51333       delete arg1;
51334     } catch (std::out_of_range& e) {
51335       {
51336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51337       };
51338     } catch (std::exception& e) {
51339       {
51340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51341       };
51342     } catch (Dali::DaliException e) {
51343       {
51344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51349       };
51350     }
51351   }
51352
51353 }
51354
51355
51356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51357   unsigned int jresult ;
51358   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51359   bool result;
51360
51361   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51362   {
51363     try {
51364       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51365     } catch (std::out_of_range& e) {
51366       {
51367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51368       };
51369     } catch (std::exception& e) {
51370       {
51371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51372       };
51373     } catch (Dali::DaliException e) {
51374       {
51375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51376       };
51377     } catch (...) {
51378       {
51379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51380       };
51381     }
51382   }
51383
51384   jresult = result;
51385   return jresult;
51386 }
51387
51388
51389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51390   unsigned long jresult ;
51391   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51392   std::size_t result;
51393
51394   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51395   {
51396     try {
51397       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51398     } catch (std::out_of_range& e) {
51399       {
51400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51401       };
51402     } catch (std::exception& e) {
51403       {
51404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51405       };
51406     } catch (Dali::DaliException e) {
51407       {
51408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51409       };
51410     } catch (...) {
51411       {
51412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51413       };
51414     }
51415   }
51416
51417   jresult = (unsigned long)result;
51418   return jresult;
51419 }
51420
51421
51422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51423   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51424   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51425
51426   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51427   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51428   {
51429     try {
51430       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51431     } catch (std::out_of_range& e) {
51432       {
51433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51434       };
51435     } catch (std::exception& e) {
51436       {
51437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51438       };
51439     } catch (Dali::DaliException e) {
51440       {
51441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51442       };
51443     } catch (...) {
51444       {
51445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51446       };
51447     }
51448   }
51449
51450 }
51451
51452
51453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51454   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51455   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51456
51457   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51458   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51459   {
51460     try {
51461       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51462     } catch (std::out_of_range& e) {
51463       {
51464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51465       };
51466     } catch (std::exception& e) {
51467       {
51468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51469       };
51470     } catch (Dali::DaliException e) {
51471       {
51472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51473       };
51474     } catch (...) {
51475       {
51476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51477       };
51478     }
51479   }
51480
51481 }
51482
51483
51484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51485   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51486   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51487
51488   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51489   arg2 = (Dali::RefObject *)jarg2;
51490   {
51491     try {
51492       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51493     } catch (std::out_of_range& e) {
51494       {
51495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51496       };
51497     } catch (std::exception& e) {
51498       {
51499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (Dali::DaliException e) {
51502       {
51503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511
51512 }
51513
51514
51515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51516   void * jresult ;
51517   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51518
51519   {
51520     try {
51521       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51529       };
51530     } catch (Dali::DaliException e) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51533       };
51534     } catch (...) {
51535       {
51536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51537       };
51538     }
51539   }
51540
51541   jresult = (void *)result;
51542   return jresult;
51543 }
51544
51545
51546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51547   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51548
51549   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51550   {
51551     try {
51552       delete arg1;
51553     } catch (std::out_of_range& e) {
51554       {
51555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51556       };
51557     } catch (std::exception& e) {
51558       {
51559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51560       };
51561     } catch (Dali::DaliException e) {
51562       {
51563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51564       };
51565     } catch (...) {
51566       {
51567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51568       };
51569     }
51570   }
51571
51572 }
51573
51574
51575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51576   unsigned int jresult ;
51577   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51578   bool result;
51579
51580   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51581   {
51582     try {
51583       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51584     } catch (std::out_of_range& e) {
51585       {
51586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51587       };
51588     } catch (std::exception& e) {
51589       {
51590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51591       };
51592     } catch (Dali::DaliException e) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51595       };
51596     } catch (...) {
51597       {
51598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51599       };
51600     }
51601   }
51602
51603   jresult = result;
51604   return jresult;
51605 }
51606
51607
51608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51609   unsigned long jresult ;
51610   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51611   std::size_t result;
51612
51613   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51614   {
51615     try {
51616       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51617     } catch (std::out_of_range& e) {
51618       {
51619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (std::exception& e) {
51622       {
51623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51624       };
51625     } catch (Dali::DaliException e) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51628       };
51629     } catch (...) {
51630       {
51631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51632       };
51633     }
51634   }
51635
51636   jresult = (unsigned long)result;
51637   return jresult;
51638 }
51639
51640
51641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51642   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51643   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51644
51645   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51646   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51647   {
51648     try {
51649       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51650     } catch (std::out_of_range& e) {
51651       {
51652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51653       };
51654     } catch (std::exception& e) {
51655       {
51656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51657       };
51658     } catch (Dali::DaliException e) {
51659       {
51660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51661       };
51662     } catch (...) {
51663       {
51664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51665       };
51666     }
51667   }
51668
51669 }
51670
51671
51672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51673   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51674   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51675
51676   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51677   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51678   {
51679     try {
51680       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51681     } catch (std::out_of_range& e) {
51682       {
51683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51684       };
51685     } catch (std::exception& e) {
51686       {
51687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51688       };
51689     } catch (Dali::DaliException e) {
51690       {
51691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51692       };
51693     } catch (...) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51696       };
51697     }
51698   }
51699
51700 }
51701
51702
51703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51704   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51705   Dali::PropertyNotification *arg2 = 0 ;
51706
51707   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51708   arg2 = (Dali::PropertyNotification *)jarg2;
51709   if (!arg2) {
51710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51711     return ;
51712   }
51713   {
51714     try {
51715       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51716     } catch (std::out_of_range& e) {
51717       {
51718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51719       };
51720     } catch (std::exception& e) {
51721       {
51722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51723       };
51724     } catch (Dali::DaliException e) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51727       };
51728     } catch (...) {
51729       {
51730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51731       };
51732     }
51733   }
51734
51735 }
51736
51737
51738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51739   void * jresult ;
51740   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51741
51742   {
51743     try {
51744       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51745     } catch (std::out_of_range& e) {
51746       {
51747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (std::exception& e) {
51750       {
51751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51752       };
51753     } catch (Dali::DaliException e) {
51754       {
51755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51756       };
51757     } catch (...) {
51758       {
51759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51760       };
51761     }
51762   }
51763
51764   jresult = (void *)result;
51765   return jresult;
51766 }
51767
51768
51769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51770   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51771
51772   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51773   {
51774     try {
51775       delete arg1;
51776     } catch (std::out_of_range& e) {
51777       {
51778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51779       };
51780     } catch (std::exception& e) {
51781       {
51782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51783       };
51784     } catch (Dali::DaliException e) {
51785       {
51786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51787       };
51788     } catch (...) {
51789       {
51790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51791       };
51792     }
51793   }
51794
51795 }
51796
51797
51798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51799   void * jresult ;
51800   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51801
51802   {
51803     try {
51804       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51805     } catch (std::out_of_range& e) {
51806       {
51807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51808       };
51809     } catch (std::exception& e) {
51810       {
51811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51812       };
51813     } catch (Dali::DaliException e) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51816       };
51817     } catch (...) {
51818       {
51819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51820       };
51821     }
51822   }
51823
51824   jresult = (void *)result;
51825   return jresult;
51826 }
51827
51828
51829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51830   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51831
51832   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51833   {
51834     try {
51835       delete arg1;
51836     } catch (std::out_of_range& e) {
51837       {
51838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51839       };
51840     } catch (std::exception& e) {
51841       {
51842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51843       };
51844     } catch (Dali::DaliException e) {
51845       {
51846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51847       };
51848     } catch (...) {
51849       {
51850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51851       };
51852     }
51853   }
51854
51855 }
51856
51857
51858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51859   unsigned int jresult ;
51860   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51861   bool result;
51862
51863   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51864   {
51865     try {
51866       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);
51867     } catch (std::out_of_range& e) {
51868       {
51869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51870       };
51871     } catch (std::exception& e) {
51872       {
51873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51874       };
51875     } catch (Dali::DaliException e) {
51876       {
51877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51878       };
51879     } catch (...) {
51880       {
51881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51882       };
51883     }
51884   }
51885
51886   jresult = result;
51887   return jresult;
51888 }
51889
51890
51891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51892   unsigned long jresult ;
51893   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51894   std::size_t result;
51895
51896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51897   {
51898     try {
51899       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);
51900     } catch (std::out_of_range& e) {
51901       {
51902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51903       };
51904     } catch (std::exception& e) {
51905       {
51906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51907       };
51908     } catch (Dali::DaliException e) {
51909       {
51910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51911       };
51912     } catch (...) {
51913       {
51914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51915       };
51916     }
51917   }
51918
51919   jresult = (unsigned long)result;
51920   return jresult;
51921 }
51922
51923
51924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51925   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51926   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51927
51928   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51929   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51930   {
51931     try {
51932       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51933     } catch (std::out_of_range& e) {
51934       {
51935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51936       };
51937     } catch (std::exception& e) {
51938       {
51939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51940       };
51941     } catch (Dali::DaliException e) {
51942       {
51943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51944       };
51945     } catch (...) {
51946       {
51947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51948       };
51949     }
51950   }
51951
51952 }
51953
51954
51955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51956   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51957   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51958
51959   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51960   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51961   {
51962     try {
51963       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51964     } catch (std::out_of_range& e) {
51965       {
51966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51967       };
51968     } catch (std::exception& e) {
51969       {
51970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51971       };
51972     } catch (Dali::DaliException e) {
51973       {
51974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51975       };
51976     } catch (...) {
51977       {
51978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51979       };
51980     }
51981   }
51982
51983 }
51984
51985
51986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51987   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51988   Dali::Actor arg2 ;
51989   Dali::LongPressGesture *arg3 = 0 ;
51990   Dali::Actor *argp2 ;
51991
51992   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51993   argp2 = (Dali::Actor *)jarg2;
51994   if (!argp2) {
51995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51996     return ;
51997   }
51998   arg2 = *argp2;
51999   arg3 = (Dali::LongPressGesture *)jarg3;
52000   if (!arg3) {
52001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
52002     return ;
52003   }
52004   {
52005     try {
52006       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
52007     } catch (std::out_of_range& e) {
52008       {
52009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52010       };
52011     } catch (std::exception& e) {
52012       {
52013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52014       };
52015     } catch (Dali::DaliException e) {
52016       {
52017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52018       };
52019     } catch (...) {
52020       {
52021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52022       };
52023     }
52024   }
52025
52026 }
52027
52028
52029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
52030   void * jresult ;
52031   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
52032
52033   {
52034     try {
52035       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
52036     } catch (std::out_of_range& e) {
52037       {
52038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52039       };
52040     } catch (std::exception& e) {
52041       {
52042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52043       };
52044     } catch (Dali::DaliException e) {
52045       {
52046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52047       };
52048     } catch (...) {
52049       {
52050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52051       };
52052     }
52053   }
52054
52055   jresult = (void *)result;
52056   return jresult;
52057 }
52058
52059
52060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
52061   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52062
52063   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52064   {
52065     try {
52066       delete arg1;
52067     } catch (std::out_of_range& e) {
52068       {
52069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52070       };
52071     } catch (std::exception& e) {
52072       {
52073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52074       };
52075     } catch (Dali::DaliException e) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52078       };
52079     } catch (...) {
52080       {
52081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52082       };
52083     }
52084   }
52085
52086 }
52087
52088
52089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
52090   unsigned int jresult ;
52091   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52092   bool result;
52093
52094   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52095   {
52096     try {
52097       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
52098     } catch (std::out_of_range& e) {
52099       {
52100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52101       };
52102     } catch (std::exception& e) {
52103       {
52104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52105       };
52106     } catch (Dali::DaliException e) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52109       };
52110     } catch (...) {
52111       {
52112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52113       };
52114     }
52115   }
52116
52117   jresult = result;
52118   return jresult;
52119 }
52120
52121
52122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
52123   unsigned long jresult ;
52124   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52125   std::size_t result;
52126
52127   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52128   {
52129     try {
52130       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
52131     } catch (std::out_of_range& e) {
52132       {
52133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52134       };
52135     } catch (std::exception& e) {
52136       {
52137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52138       };
52139     } catch (Dali::DaliException e) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52142       };
52143     } catch (...) {
52144       {
52145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52146       };
52147     }
52148   }
52149
52150   jresult = (unsigned long)result;
52151   return jresult;
52152 }
52153
52154
52155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
52156   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52157   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
52158
52159   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52160   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
52161   {
52162     try {
52163       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52164     } catch (std::out_of_range& e) {
52165       {
52166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52167       };
52168     } catch (std::exception& e) {
52169       {
52170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52171       };
52172     } catch (Dali::DaliException e) {
52173       {
52174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52175       };
52176     } catch (...) {
52177       {
52178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52179       };
52180     }
52181   }
52182
52183 }
52184
52185
52186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52187   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52188   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
52189
52190   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52191   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
52192   {
52193     try {
52194       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52195     } catch (std::out_of_range& e) {
52196       {
52197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52198       };
52199     } catch (std::exception& e) {
52200       {
52201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52202       };
52203     } catch (Dali::DaliException e) {
52204       {
52205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52206       };
52207     } catch (...) {
52208       {
52209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52210       };
52211     }
52212   }
52213
52214 }
52215
52216
52217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52218   unsigned int jresult ;
52219   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52220   Dali::Actor arg2 ;
52221   Dali::TouchEvent *arg3 = 0 ;
52222   Dali::Actor *argp2 ;
52223   bool result;
52224
52225   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52226   argp2 = (Dali::Actor *)jarg2;
52227   if (!argp2) {
52228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52229     return 0;
52230   }
52231   arg2 = *argp2;
52232   arg3 = (Dali::TouchEvent *)jarg3;
52233   if (!arg3) {
52234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
52235     return 0;
52236   }
52237   {
52238     try {
52239       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
52240     } catch (std::out_of_range& e) {
52241       {
52242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52243       };
52244     } catch (std::exception& e) {
52245       {
52246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52247       };
52248     } catch (Dali::DaliException e) {
52249       {
52250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52251       };
52252     } catch (...) {
52253       {
52254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52255       };
52256     }
52257   }
52258
52259   jresult = result;
52260   return jresult;
52261 }
52262
52263
52264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52265   void * jresult ;
52266   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
52267
52268   {
52269     try {
52270       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
52271     } catch (std::out_of_range& e) {
52272       {
52273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52274       };
52275     } catch (std::exception& e) {
52276       {
52277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52278       };
52279     } catch (Dali::DaliException e) {
52280       {
52281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52282       };
52283     } catch (...) {
52284       {
52285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52286       };
52287     }
52288   }
52289
52290   jresult = (void *)result;
52291   return jresult;
52292 }
52293
52294
52295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52296   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52297
52298   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52299   {
52300     try {
52301       delete arg1;
52302     } catch (std::out_of_range& e) {
52303       {
52304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (std::exception& e) {
52307       {
52308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52309       };
52310     } catch (Dali::DaliException e) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52313       };
52314     } catch (...) {
52315       {
52316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52317       };
52318     }
52319   }
52320
52321 }
52322
52323
52324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52325   unsigned int jresult ;
52326   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52327   bool result;
52328
52329   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52330   {
52331     try {
52332       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);
52333     } catch (std::out_of_range& e) {
52334       {
52335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (std::exception& e) {
52338       {
52339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52340       };
52341     } catch (Dali::DaliException e) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52344       };
52345     } catch (...) {
52346       {
52347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52348       };
52349     }
52350   }
52351
52352   jresult = result;
52353   return jresult;
52354 }
52355
52356
52357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52358   unsigned long jresult ;
52359   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52360   std::size_t result;
52361
52362   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52363   {
52364     try {
52365       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);
52366     } catch (std::out_of_range& e) {
52367       {
52368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52369       };
52370     } catch (std::exception& e) {
52371       {
52372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52373       };
52374     } catch (Dali::DaliException e) {
52375       {
52376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52377       };
52378     } catch (...) {
52379       {
52380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52381       };
52382     }
52383   }
52384
52385   jresult = (unsigned long)result;
52386   return jresult;
52387 }
52388
52389
52390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52391   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52392   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52393
52394   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52395   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52396   {
52397     try {
52398       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52399     } catch (std::out_of_range& e) {
52400       {
52401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52402       };
52403     } catch (std::exception& e) {
52404       {
52405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52406       };
52407     } catch (Dali::DaliException e) {
52408       {
52409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52410       };
52411     } catch (...) {
52412       {
52413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52414       };
52415     }
52416   }
52417
52418 }
52419
52420
52421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52422   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52423   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52424
52425   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52426   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52427   {
52428     try {
52429       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52430     } catch (std::out_of_range& e) {
52431       {
52432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52433       };
52434     } catch (std::exception& e) {
52435       {
52436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52437       };
52438     } catch (Dali::DaliException e) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52441       };
52442     } catch (...) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52445       };
52446     }
52447   }
52448
52449 }
52450
52451
52452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52453   unsigned int jresult ;
52454   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52455   Dali::Actor arg2 ;
52456   Dali::HoverEvent *arg3 = 0 ;
52457   Dali::Actor *argp2 ;
52458   bool result;
52459
52460   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52461   argp2 = (Dali::Actor *)jarg2;
52462   if (!argp2) {
52463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52464     return 0;
52465   }
52466   arg2 = *argp2;
52467   arg3 = (Dali::HoverEvent *)jarg3;
52468   if (!arg3) {
52469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52470     return 0;
52471   }
52472   {
52473     try {
52474       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52475     } catch (std::out_of_range& e) {
52476       {
52477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52478       };
52479     } catch (std::exception& e) {
52480       {
52481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52482       };
52483     } catch (Dali::DaliException e) {
52484       {
52485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52486       };
52487     } catch (...) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52490       };
52491     }
52492   }
52493
52494   jresult = result;
52495   return jresult;
52496 }
52497
52498
52499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52500   void * jresult ;
52501   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52502
52503   {
52504     try {
52505       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52506     } catch (std::out_of_range& e) {
52507       {
52508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52509       };
52510     } catch (std::exception& e) {
52511       {
52512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52513       };
52514     } catch (Dali::DaliException e) {
52515       {
52516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52517       };
52518     } catch (...) {
52519       {
52520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52521       };
52522     }
52523   }
52524
52525   jresult = (void *)result;
52526   return jresult;
52527 }
52528
52529
52530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52531   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52532
52533   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52534   {
52535     try {
52536       delete arg1;
52537     } catch (std::out_of_range& e) {
52538       {
52539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52540       };
52541     } catch (std::exception& e) {
52542       {
52543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52544       };
52545     } catch (Dali::DaliException e) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52548       };
52549     } catch (...) {
52550       {
52551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52552       };
52553     }
52554   }
52555
52556 }
52557
52558
52559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52560   unsigned int jresult ;
52561   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52562   bool result;
52563
52564   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52565   {
52566     try {
52567       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);
52568     } catch (std::out_of_range& e) {
52569       {
52570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52571       };
52572     } catch (std::exception& e) {
52573       {
52574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52575       };
52576     } catch (Dali::DaliException e) {
52577       {
52578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52583       };
52584     }
52585   }
52586
52587   jresult = result;
52588   return jresult;
52589 }
52590
52591
52592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52593   unsigned long jresult ;
52594   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52595   std::size_t result;
52596
52597   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52598   {
52599     try {
52600       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);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52616       };
52617     }
52618   }
52619
52620   jresult = (unsigned long)result;
52621   return jresult;
52622 }
52623
52624
52625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52626   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52627   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52628
52629   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52630   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52631   {
52632     try {
52633       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52641       };
52642     } catch (Dali::DaliException e) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52645       };
52646     } catch (...) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52649       };
52650     }
52651   }
52652
52653 }
52654
52655
52656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52657   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52658   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52659
52660   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52661   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52662   {
52663     try {
52664       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52665     } catch (std::out_of_range& e) {
52666       {
52667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52668       };
52669     } catch (std::exception& e) {
52670       {
52671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52672       };
52673     } catch (Dali::DaliException e) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52676       };
52677     } catch (...) {
52678       {
52679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52680       };
52681     }
52682   }
52683
52684 }
52685
52686
52687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52688   unsigned int jresult ;
52689   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52690   Dali::Actor arg2 ;
52691   Dali::WheelEvent *arg3 = 0 ;
52692   Dali::Actor *argp2 ;
52693   bool result;
52694
52695   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52696   argp2 = (Dali::Actor *)jarg2;
52697   if (!argp2) {
52698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52699     return 0;
52700   }
52701   arg2 = *argp2;
52702   arg3 = (Dali::WheelEvent *)jarg3;
52703   if (!arg3) {
52704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52705     return 0;
52706   }
52707   {
52708     try {
52709       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52710     } catch (std::out_of_range& e) {
52711       {
52712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52713       };
52714     } catch (std::exception& e) {
52715       {
52716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52717       };
52718     } catch (Dali::DaliException e) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52721       };
52722     } catch (...) {
52723       {
52724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52725       };
52726     }
52727   }
52728
52729   jresult = result;
52730   return jresult;
52731 }
52732
52733
52734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52735   void * jresult ;
52736   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52737
52738   {
52739     try {
52740       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52741     } catch (std::out_of_range& e) {
52742       {
52743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52744       };
52745     } catch (std::exception& e) {
52746       {
52747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52748       };
52749     } catch (Dali::DaliException e) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52752       };
52753     } catch (...) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52756       };
52757     }
52758   }
52759
52760   jresult = (void *)result;
52761   return jresult;
52762 }
52763
52764
52765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52766   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52767
52768   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52769   {
52770     try {
52771       delete arg1;
52772     } catch (std::out_of_range& e) {
52773       {
52774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52775       };
52776     } catch (std::exception& e) {
52777       {
52778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52779       };
52780     } catch (Dali::DaliException e) {
52781       {
52782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52783       };
52784     } catch (...) {
52785       {
52786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52787       };
52788     }
52789   }
52790
52791 }
52792
52793
52794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52795   unsigned int jresult ;
52796   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52797   bool result;
52798
52799   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52800   {
52801     try {
52802       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52803     } catch (std::out_of_range& e) {
52804       {
52805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52806       };
52807     } catch (std::exception& e) {
52808       {
52809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52810       };
52811     } catch (Dali::DaliException e) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52814       };
52815     } catch (...) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52818       };
52819     }
52820   }
52821
52822   jresult = result;
52823   return jresult;
52824 }
52825
52826
52827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52828   unsigned long jresult ;
52829   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52830   std::size_t result;
52831
52832   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52833   {
52834     try {
52835       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52836     } catch (std::out_of_range& e) {
52837       {
52838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52839       };
52840     } catch (std::exception& e) {
52841       {
52842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52843       };
52844     } catch (Dali::DaliException e) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52847       };
52848     } catch (...) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52851       };
52852     }
52853   }
52854
52855   jresult = (unsigned long)result;
52856   return jresult;
52857 }
52858
52859
52860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52861   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52862   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52863
52864   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52865   arg2 = (void (*)(Dali::Actor))jarg2;
52866   {
52867     try {
52868       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52869     } catch (std::out_of_range& e) {
52870       {
52871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52872       };
52873     } catch (std::exception& e) {
52874       {
52875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52876       };
52877     } catch (Dali::DaliException e) {
52878       {
52879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52880       };
52881     } catch (...) {
52882       {
52883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52884       };
52885     }
52886   }
52887
52888 }
52889
52890
52891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52892   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52893   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52894
52895   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52896   arg2 = (void (*)(Dali::Actor))jarg2;
52897   {
52898     try {
52899       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52900     } catch (std::out_of_range& e) {
52901       {
52902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52903       };
52904     } catch (std::exception& e) {
52905       {
52906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52907       };
52908     } catch (Dali::DaliException e) {
52909       {
52910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52911       };
52912     } catch (...) {
52913       {
52914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52915       };
52916     }
52917   }
52918
52919 }
52920
52921
52922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52923   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52924   Dali::Actor arg2 ;
52925   Dali::Actor *argp2 ;
52926
52927   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52928   argp2 = (Dali::Actor *)jarg2;
52929   if (!argp2) {
52930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52931     return ;
52932   }
52933   arg2 = *argp2;
52934   {
52935     try {
52936       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52937     } catch (std::out_of_range& e) {
52938       {
52939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52940       };
52941     } catch (std::exception& e) {
52942       {
52943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52944       };
52945     } catch (Dali::DaliException e) {
52946       {
52947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52948       };
52949     } catch (...) {
52950       {
52951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52952       };
52953     }
52954   }
52955
52956 }
52957
52958
52959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52960   void * jresult ;
52961   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52962
52963   {
52964     try {
52965       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52966     } catch (std::out_of_range& e) {
52967       {
52968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52969       };
52970     } catch (std::exception& e) {
52971       {
52972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (Dali::DaliException e) {
52975       {
52976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52981       };
52982     }
52983   }
52984
52985   jresult = (void *)result;
52986   return jresult;
52987 }
52988
52989
52990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52991   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52992
52993   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52994   {
52995     try {
52996       delete arg1;
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 (Dali::DaliException e) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53008       };
53009     } catch (...) {
53010       {
53011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53012       };
53013     }
53014   }
53015
53016 }
53017
53018
53019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
53020   unsigned int jresult ;
53021   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53022   bool result;
53023
53024   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53025   {
53026     try {
53027       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53028     } catch (std::out_of_range& e) {
53029       {
53030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53031       };
53032     } catch (std::exception& e) {
53033       {
53034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53035       };
53036     } catch (Dali::DaliException e) {
53037       {
53038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53039       };
53040     } catch (...) {
53041       {
53042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53043       };
53044     }
53045   }
53046
53047   jresult = result;
53048   return jresult;
53049 }
53050
53051
53052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
53053   unsigned long jresult ;
53054   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53055   std::size_t result;
53056
53057   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53058   {
53059     try {
53060       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53061     } catch (std::out_of_range& e) {
53062       {
53063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53064       };
53065     } catch (std::exception& e) {
53066       {
53067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53068       };
53069     } catch (Dali::DaliException e) {
53070       {
53071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53072       };
53073     } catch (...) {
53074       {
53075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53076       };
53077     }
53078   }
53079
53080   jresult = (unsigned long)result;
53081   return jresult;
53082 }
53083
53084
53085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
53086   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53087   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53088
53089   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53090   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53091   {
53092     try {
53093       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53094     } catch (std::out_of_range& e) {
53095       {
53096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53097       };
53098     } catch (std::exception& e) {
53099       {
53100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53101       };
53102     } catch (Dali::DaliException e) {
53103       {
53104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53109       };
53110     }
53111   }
53112
53113 }
53114
53115
53116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
53117   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53118   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53119
53120   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53121   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53122   {
53123     try {
53124       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53125     } catch (std::out_of_range& e) {
53126       {
53127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53128       };
53129     } catch (std::exception& e) {
53130       {
53131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53132       };
53133     } catch (Dali::DaliException e) {
53134       {
53135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53136       };
53137     } catch (...) {
53138       {
53139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53140       };
53141     }
53142   }
53143
53144 }
53145
53146
53147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
53148   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53149   Dali::KeyEvent *arg2 = 0 ;
53150
53151   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53152   arg2 = (Dali::KeyEvent *)jarg2;
53153   if (!arg2) {
53154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
53155     return ;
53156   }
53157   {
53158     try {
53159       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
53160     } catch (std::out_of_range& e) {
53161       {
53162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53163       };
53164     } catch (std::exception& e) {
53165       {
53166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53167       };
53168     } catch (Dali::DaliException e) {
53169       {
53170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53171       };
53172     } catch (...) {
53173       {
53174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53175       };
53176     }
53177   }
53178
53179 }
53180
53181
53182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53183   void * jresult ;
53184   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53185
53186   {
53187     try {
53188       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53189     } catch (std::out_of_range& e) {
53190       {
53191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53192       };
53193     } catch (std::exception& e) {
53194       {
53195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53196       };
53197     } catch (Dali::DaliException e) {
53198       {
53199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53200       };
53201     } catch (...) {
53202       {
53203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53204       };
53205     }
53206   }
53207
53208   jresult = (void *)result;
53209   return jresult;
53210 }
53211
53212
53213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53214   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53215
53216   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53217   {
53218     try {
53219       delete arg1;
53220     } catch (std::out_of_range& e) {
53221       {
53222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53223       };
53224     } catch (std::exception& e) {
53225       {
53226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53227       };
53228     } catch (Dali::DaliException e) {
53229       {
53230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53231       };
53232     } catch (...) {
53233       {
53234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53235       };
53236     }
53237   }
53238
53239 }
53240
53241
53242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53243   unsigned int jresult ;
53244   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53245   bool result;
53246
53247   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53248   {
53249     try {
53250       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53251     } catch (std::out_of_range& e) {
53252       {
53253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53254       };
53255     } catch (std::exception& e) {
53256       {
53257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53258       };
53259     } catch (Dali::DaliException e) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53262       };
53263     } catch (...) {
53264       {
53265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53266       };
53267     }
53268   }
53269
53270   jresult = result;
53271   return jresult;
53272 }
53273
53274
53275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53276   unsigned long jresult ;
53277   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53278   std::size_t result;
53279
53280   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53281   {
53282     try {
53283       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53284     } catch (std::out_of_range& e) {
53285       {
53286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53287       };
53288     } catch (std::exception& e) {
53289       {
53290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53291       };
53292     } catch (Dali::DaliException e) {
53293       {
53294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53295       };
53296     } catch (...) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53299       };
53300     }
53301   }
53302
53303   jresult = (unsigned long)result;
53304   return jresult;
53305 }
53306
53307
53308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53309   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53310   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53311
53312   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53313   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53314   {
53315     try {
53316       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53317     } catch (std::out_of_range& e) {
53318       {
53319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (std::exception& e) {
53322       {
53323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53324       };
53325     } catch (Dali::DaliException e) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53328       };
53329     } catch (...) {
53330       {
53331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53332       };
53333     }
53334   }
53335
53336 }
53337
53338
53339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53340   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53341   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53342
53343   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53344   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53345   {
53346     try {
53347       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53348     } catch (std::out_of_range& e) {
53349       {
53350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53351       };
53352     } catch (std::exception& e) {
53353       {
53354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53355       };
53356     } catch (Dali::DaliException e) {
53357       {
53358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53359       };
53360     } catch (...) {
53361       {
53362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53363       };
53364     }
53365   }
53366
53367 }
53368
53369
53370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53371   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53372   Dali::TouchEvent *arg2 = 0 ;
53373
53374   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53375   arg2 = (Dali::TouchEvent *)jarg2;
53376   if (!arg2) {
53377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53378     return ;
53379   }
53380   {
53381     try {
53382       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53383     } catch (std::out_of_range& e) {
53384       {
53385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53386       };
53387     } catch (std::exception& e) {
53388       {
53389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53390       };
53391     } catch (Dali::DaliException e) {
53392       {
53393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53394       };
53395     } catch (...) {
53396       {
53397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53398       };
53399     }
53400   }
53401
53402 }
53403
53404
53405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53406   void * jresult ;
53407   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53408
53409   {
53410     try {
53411       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53412     } catch (std::out_of_range& e) {
53413       {
53414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53415       };
53416     } catch (std::exception& e) {
53417       {
53418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53419       };
53420     } catch (Dali::DaliException e) {
53421       {
53422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53423       };
53424     } catch (...) {
53425       {
53426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53427       };
53428     }
53429   }
53430
53431   jresult = (void *)result;
53432   return jresult;
53433 }
53434
53435
53436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53437   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53438
53439   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53440   {
53441     try {
53442       delete arg1;
53443     } catch (std::out_of_range& e) {
53444       {
53445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53446       };
53447     } catch (std::exception& e) {
53448       {
53449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (Dali::DaliException e) {
53452       {
53453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53454       };
53455     } catch (...) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53458       };
53459     }
53460   }
53461
53462 }
53463
53464
53465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53466   unsigned int jresult ;
53467   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53468   bool result;
53469
53470   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53471   {
53472     try {
53473       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53474     } catch (std::out_of_range& e) {
53475       {
53476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53477       };
53478     } catch (std::exception& e) {
53479       {
53480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53481       };
53482     } catch (Dali::DaliException e) {
53483       {
53484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53485       };
53486     } catch (...) {
53487       {
53488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53489       };
53490     }
53491   }
53492
53493   jresult = result;
53494   return jresult;
53495 }
53496
53497
53498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53499   unsigned long jresult ;
53500   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53501   std::size_t result;
53502
53503   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53504   {
53505     try {
53506       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53514       };
53515     } catch (Dali::DaliException e) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53518       };
53519     } catch (...) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53522       };
53523     }
53524   }
53525
53526   jresult = (unsigned long)result;
53527   return jresult;
53528 }
53529
53530
53531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53532   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53533   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53534
53535   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53536   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53537   {
53538     try {
53539       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53540     } catch (std::out_of_range& e) {
53541       {
53542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53543       };
53544     } catch (std::exception& e) {
53545       {
53546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53547       };
53548     } catch (Dali::DaliException e) {
53549       {
53550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53551       };
53552     } catch (...) {
53553       {
53554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53555       };
53556     }
53557   }
53558
53559 }
53560
53561
53562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53563   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53564   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53565
53566   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53567   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53568   {
53569     try {
53570       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53571     } catch (std::out_of_range& e) {
53572       {
53573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53574       };
53575     } catch (std::exception& e) {
53576       {
53577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53578       };
53579     } catch (Dali::DaliException e) {
53580       {
53581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53582       };
53583     } catch (...) {
53584       {
53585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53586       };
53587     }
53588   }
53589
53590 }
53591
53592
53593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53594   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53595   Dali::WheelEvent *arg2 = 0 ;
53596
53597   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53598   arg2 = (Dali::WheelEvent *)jarg2;
53599   if (!arg2) {
53600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53601     return ;
53602   }
53603   {
53604     try {
53605       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53606     } catch (std::out_of_range& e) {
53607       {
53608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53609       };
53610     } catch (std::exception& e) {
53611       {
53612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53613       };
53614     } catch (Dali::DaliException e) {
53615       {
53616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53617       };
53618     } catch (...) {
53619       {
53620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53621       };
53622     }
53623   }
53624
53625 }
53626
53627
53628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53629   void * jresult ;
53630   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53631
53632   {
53633     try {
53634       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53635     } catch (std::out_of_range& e) {
53636       {
53637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53638       };
53639     } catch (std::exception& e) {
53640       {
53641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53642       };
53643     } catch (Dali::DaliException e) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53646       };
53647     } catch (...) {
53648       {
53649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53650       };
53651     }
53652   }
53653
53654   jresult = (void *)result;
53655   return jresult;
53656 }
53657
53658
53659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53660   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53661
53662   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53663   {
53664     try {
53665       delete arg1;
53666     } catch (std::out_of_range& e) {
53667       {
53668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53669       };
53670     } catch (std::exception& e) {
53671       {
53672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53673       };
53674     } catch (Dali::DaliException e) {
53675       {
53676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53677       };
53678     } catch (...) {
53679       {
53680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53681       };
53682     }
53683   }
53684
53685 }
53686
53687
53688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53689   void * jresult ;
53690   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53691
53692   {
53693     try {
53694       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53695     } catch (std::out_of_range& e) {
53696       {
53697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53698       };
53699     } catch (std::exception& e) {
53700       {
53701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53702       };
53703     } catch (Dali::DaliException e) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53706       };
53707     } catch (...) {
53708       {
53709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53710       };
53711     }
53712   }
53713
53714   jresult = (void *)result;
53715   return jresult;
53716 }
53717
53718
53719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53720   void * jresult ;
53721   Dali::Radian arg1 ;
53722   Dali::Radian arg2 ;
53723   Dali::Radian *argp1 ;
53724   Dali::Radian *argp2 ;
53725   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53726
53727   argp1 = (Dali::Radian *)jarg1;
53728   if (!argp1) {
53729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53730     return 0;
53731   }
53732   arg1 = *argp1;
53733   argp2 = (Dali::Radian *)jarg2;
53734   if (!argp2) {
53735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53736     return 0;
53737   }
53738   arg2 = *argp2;
53739   {
53740     try {
53741       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53742     } catch (std::out_of_range& e) {
53743       {
53744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53745       };
53746     } catch (std::exception& e) {
53747       {
53748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53749       };
53750     } catch (Dali::DaliException e) {
53751       {
53752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53753       };
53754     } catch (...) {
53755       {
53756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53757       };
53758     }
53759   }
53760
53761   jresult = (void *)result;
53762   return jresult;
53763 }
53764
53765
53766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53767   void * jresult ;
53768   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53769   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53770
53771   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53772   if (!arg1) {
53773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53774     return 0;
53775   }
53776   {
53777     try {
53778       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53779     } catch (std::out_of_range& e) {
53780       {
53781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53782       };
53783     } catch (std::exception& e) {
53784       {
53785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53786       };
53787     } catch (Dali::DaliException e) {
53788       {
53789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53790       };
53791     } catch (...) {
53792       {
53793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53794       };
53795     }
53796   }
53797
53798   jresult = (void *)result;
53799   return jresult;
53800 }
53801
53802
53803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53804   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53805   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53806
53807   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53808   arg2 = (Dali::Radian *)jarg2;
53809   if (arg1) (arg1)->first = *arg2;
53810 }
53811
53812
53813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53814   void * jresult ;
53815   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53816   Dali::Radian *result = 0 ;
53817
53818   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53819   result = (Dali::Radian *)& ((arg1)->first);
53820   jresult = (void *)result;
53821   return jresult;
53822 }
53823
53824
53825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53826   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53827   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53828
53829   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53830   arg2 = (Dali::Radian *)jarg2;
53831   if (arg1) (arg1)->second = *arg2;
53832 }
53833
53834
53835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53836   void * jresult ;
53837   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53838   Dali::Radian *result = 0 ;
53839
53840   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53841   result = (Dali::Radian *)& ((arg1)->second);
53842   jresult = (void *)result;
53843   return jresult;
53844 }
53845
53846
53847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53848   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53849
53850   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53851   {
53852     try {
53853       delete arg1;
53854     } catch (std::out_of_range& e) {
53855       {
53856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53857       };
53858     } catch (std::exception& e) {
53859       {
53860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53861       };
53862     } catch (Dali::DaliException e) {
53863       {
53864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53865       };
53866     } catch (...) {
53867       {
53868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53869       };
53870     }
53871   }
53872
53873 }
53874
53875
53876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53877   unsigned int jresult ;
53878   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53879   bool result;
53880
53881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53882   {
53883     try {
53884       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);
53885     } catch (std::out_of_range& e) {
53886       {
53887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53888       };
53889     } catch (std::exception& e) {
53890       {
53891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53892       };
53893     } catch (Dali::DaliException e) {
53894       {
53895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53896       };
53897     } catch (...) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53900       };
53901     }
53902   }
53903
53904   jresult = result;
53905   return jresult;
53906 }
53907
53908
53909 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53910   unsigned long jresult ;
53911   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53912   std::size_t result;
53913
53914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53915   {
53916     try {
53917       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);
53918     } catch (std::out_of_range& e) {
53919       {
53920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53921       };
53922     } catch (std::exception& e) {
53923       {
53924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53925       };
53926     } catch (Dali::DaliException e) {
53927       {
53928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53929       };
53930     } catch (...) {
53931       {
53932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53933       };
53934     }
53935   }
53936
53937   jresult = (unsigned long)result;
53938   return jresult;
53939 }
53940
53941
53942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53943   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53944   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53945
53946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53947   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53948   {
53949     try {
53950       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53951     } catch (std::out_of_range& e) {
53952       {
53953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53954       };
53955     } catch (std::exception& e) {
53956       {
53957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53958       };
53959     } catch (Dali::DaliException e) {
53960       {
53961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53962       };
53963     } catch (...) {
53964       {
53965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53966       };
53967     }
53968   }
53969
53970 }
53971
53972
53973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53974   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53975   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53976
53977   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53978   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53979   {
53980     try {
53981       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53982     } catch (std::out_of_range& e) {
53983       {
53984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (std::exception& e) {
53987       {
53988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53989       };
53990     } catch (Dali::DaliException e) {
53991       {
53992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53993       };
53994     } catch (...) {
53995       {
53996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53997       };
53998     }
53999   }
54000
54001 }
54002
54003
54004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54005   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54006   Dali::Actor arg2 ;
54007   Dali::PanGesture *arg3 = 0 ;
54008   Dali::Actor *argp2 ;
54009
54010   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54011   argp2 = (Dali::Actor *)jarg2;
54012   if (!argp2) {
54013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54014     return ;
54015   }
54016   arg2 = *argp2;
54017   arg3 = (Dali::PanGesture *)jarg3;
54018   if (!arg3) {
54019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
54020     return ;
54021   }
54022   {
54023     try {
54024       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
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 (Dali::DaliException e) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54036       };
54037     } catch (...) {
54038       {
54039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54040       };
54041     }
54042   }
54043
54044 }
54045
54046
54047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
54048   void * jresult ;
54049   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
54050
54051   {
54052     try {
54053       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
54054     } catch (std::out_of_range& e) {
54055       {
54056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54057       };
54058     } catch (std::exception& e) {
54059       {
54060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54061       };
54062     } catch (Dali::DaliException e) {
54063       {
54064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54065       };
54066     } catch (...) {
54067       {
54068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54069       };
54070     }
54071   }
54072
54073   jresult = (void *)result;
54074   return jresult;
54075 }
54076
54077
54078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
54079   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54080
54081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54082   {
54083     try {
54084       delete arg1;
54085     } catch (std::out_of_range& e) {
54086       {
54087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54088       };
54089     } catch (std::exception& e) {
54090       {
54091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54092       };
54093     } catch (Dali::DaliException e) {
54094       {
54095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54096       };
54097     } catch (...) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54100       };
54101     }
54102   }
54103
54104 }
54105
54106
54107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
54108   unsigned int jresult ;
54109   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54110   bool result;
54111
54112   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54113   {
54114     try {
54115       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);
54116     } catch (std::out_of_range& e) {
54117       {
54118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54119       };
54120     } catch (std::exception& e) {
54121       {
54122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54123       };
54124     } catch (Dali::DaliException e) {
54125       {
54126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54127       };
54128     } catch (...) {
54129       {
54130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54131       };
54132     }
54133   }
54134
54135   jresult = result;
54136   return jresult;
54137 }
54138
54139
54140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54141   unsigned long jresult ;
54142   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54143   std::size_t result;
54144
54145   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54146   {
54147     try {
54148       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);
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54156       };
54157     } catch (Dali::DaliException e) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54164       };
54165     }
54166   }
54167
54168   jresult = (unsigned long)result;
54169   return jresult;
54170 }
54171
54172
54173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54174   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54175   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54176
54177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54178   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54179   {
54180     try {
54181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54182     } catch (std::out_of_range& e) {
54183       {
54184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54185       };
54186     } catch (std::exception& e) {
54187       {
54188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54189       };
54190     } catch (Dali::DaliException e) {
54191       {
54192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54193       };
54194     } catch (...) {
54195       {
54196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54197       };
54198     }
54199   }
54200
54201 }
54202
54203
54204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54205   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54206   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54207
54208   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54209   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54210   {
54211     try {
54212       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54213     } catch (std::out_of_range& e) {
54214       {
54215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54216       };
54217     } catch (std::exception& e) {
54218       {
54219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54220       };
54221     } catch (Dali::DaliException e) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54228       };
54229     }
54230   }
54231
54232 }
54233
54234
54235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54236   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54237   Dali::Actor arg2 ;
54238   Dali::PinchGesture *arg3 = 0 ;
54239   Dali::Actor *argp2 ;
54240
54241   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54242   argp2 = (Dali::Actor *)jarg2;
54243   if (!argp2) {
54244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54245     return ;
54246   }
54247   arg2 = *argp2;
54248   arg3 = (Dali::PinchGesture *)jarg3;
54249   if (!arg3) {
54250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54251     return ;
54252   }
54253   {
54254     try {
54255       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54256     } catch (std::out_of_range& e) {
54257       {
54258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54259       };
54260     } catch (std::exception& e) {
54261       {
54262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54263       };
54264     } catch (Dali::DaliException e) {
54265       {
54266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54267       };
54268     } catch (...) {
54269       {
54270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54271       };
54272     }
54273   }
54274
54275 }
54276
54277
54278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54279   void * jresult ;
54280   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54281
54282   {
54283     try {
54284       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54285     } catch (std::out_of_range& e) {
54286       {
54287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54288       };
54289     } catch (std::exception& e) {
54290       {
54291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54292       };
54293     } catch (Dali::DaliException e) {
54294       {
54295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54300       };
54301     }
54302   }
54303
54304   jresult = (void *)result;
54305   return jresult;
54306 }
54307
54308
54309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54310   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54311
54312   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54313   {
54314     try {
54315       delete arg1;
54316     } catch (std::out_of_range& e) {
54317       {
54318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54319       };
54320     } catch (std::exception& e) {
54321       {
54322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54323       };
54324     } catch (Dali::DaliException e) {
54325       {
54326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54327       };
54328     } catch (...) {
54329       {
54330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54331       };
54332     }
54333   }
54334
54335 }
54336
54337
54338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54339   unsigned int jresult ;
54340   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54341   bool result;
54342
54343   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54344   {
54345     try {
54346       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);
54347     } catch (std::out_of_range& e) {
54348       {
54349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (std::exception& e) {
54352       {
54353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54354       };
54355     } catch (Dali::DaliException e) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54358       };
54359     } catch (...) {
54360       {
54361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54362       };
54363     }
54364   }
54365
54366   jresult = result;
54367   return jresult;
54368 }
54369
54370
54371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54372   unsigned long jresult ;
54373   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54374   std::size_t result;
54375
54376   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54377   {
54378     try {
54379       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);
54380     } catch (std::out_of_range& e) {
54381       {
54382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54383       };
54384     } catch (std::exception& e) {
54385       {
54386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54387       };
54388     } catch (Dali::DaliException e) {
54389       {
54390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54391       };
54392     } catch (...) {
54393       {
54394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54395       };
54396     }
54397   }
54398
54399   jresult = (unsigned long)result;
54400   return jresult;
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54405   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54406   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54407
54408   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54409   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54410   {
54411     try {
54412       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54413     } catch (std::out_of_range& e) {
54414       {
54415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54416       };
54417     } catch (std::exception& e) {
54418       {
54419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54420       };
54421     } catch (Dali::DaliException e) {
54422       {
54423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54424       };
54425     } catch (...) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54428       };
54429     }
54430   }
54431
54432 }
54433
54434
54435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54436   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54437   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54438
54439   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54440   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54441   {
54442     try {
54443       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54444     } catch (std::out_of_range& e) {
54445       {
54446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54447       };
54448     } catch (std::exception& e) {
54449       {
54450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54451       };
54452     } catch (Dali::DaliException e) {
54453       {
54454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54455       };
54456     } catch (...) {
54457       {
54458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54459       };
54460     }
54461   }
54462
54463 }
54464
54465
54466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54467   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54468   Dali::Actor arg2 ;
54469   Dali::TapGesture *arg3 = 0 ;
54470   Dali::Actor *argp2 ;
54471
54472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54473   argp2 = (Dali::Actor *)jarg2;
54474   if (!argp2) {
54475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54476     return ;
54477   }
54478   arg2 = *argp2;
54479   arg3 = (Dali::TapGesture *)jarg3;
54480   if (!arg3) {
54481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54482     return ;
54483   }
54484   {
54485     try {
54486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54487     } catch (std::out_of_range& e) {
54488       {
54489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54490       };
54491     } catch (std::exception& e) {
54492       {
54493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54494       };
54495     } catch (Dali::DaliException e) {
54496       {
54497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54498       };
54499     } catch (...) {
54500       {
54501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54502       };
54503     }
54504   }
54505
54506 }
54507
54508
54509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54510   void * jresult ;
54511   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54512
54513   {
54514     try {
54515       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54516     } catch (std::out_of_range& e) {
54517       {
54518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54519       };
54520     } catch (std::exception& e) {
54521       {
54522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54523       };
54524     } catch (Dali::DaliException e) {
54525       {
54526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54527       };
54528     } catch (...) {
54529       {
54530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54531       };
54532     }
54533   }
54534
54535   jresult = (void *)result;
54536   return jresult;
54537 }
54538
54539
54540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54541   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54542
54543   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54544   {
54545     try {
54546       delete arg1;
54547     } catch (std::out_of_range& e) {
54548       {
54549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54550       };
54551     } catch (std::exception& e) {
54552       {
54553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54554       };
54555     } catch (Dali::DaliException e) {
54556       {
54557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54558       };
54559     } catch (...) {
54560       {
54561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54562       };
54563     }
54564   }
54565
54566 }
54567
54568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54569   unsigned int jresult ;
54570   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54571   bool result = false;
54572
54573   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54574   {
54575     try {
54576       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
54577     } catch (std::out_of_range& e) {
54578       {
54579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54580       };
54581     } catch (std::exception& e) {
54582       {
54583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54584       };
54585     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54586   }
54587   jresult = result;
54588   return jresult;
54589 }
54590
54591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54592   unsigned long jresult ;
54593   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54594   std::size_t result = 0;
54595
54596   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54597   {
54598     try {
54599       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
54600     } catch (std::out_of_range& e) {
54601       {
54602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54603       };
54604     } catch (std::exception& e) {
54605       {
54606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54607       };
54608     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54609   }
54610   jresult = (unsigned long)result;
54611   return jresult;
54612 }
54613
54614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54615   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54616   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54617
54618   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54619   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54620   {
54621     try {
54622       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54623     } catch (std::out_of_range& e) {
54624       {
54625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54626       };
54627     } catch (std::exception& e) {
54628       {
54629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54630       };
54631     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54632   }
54633 }
54634
54635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54636   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54637   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54638
54639   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54640   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54641   {
54642     try {
54643       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54651       };
54652     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54653   }
54654 }
54655
54656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54657   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54658   Dali::Actor arg2 ;
54659   //bool arg3 ;
54660   Dali::LayoutDirection::Type arg4 ;
54661   Dali::Actor *argp2 ;
54662
54663   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54664   argp2 = (Dali::Actor *)jarg2;
54665   if (!argp2) {
54666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54667     return ;
54668   }
54669   arg2 = *argp2;
54670   //arg3 = jarg3 ? true : false;
54671   arg4 = (Dali::LayoutDirection::Type)jarg4;
54672   {
54673     try {
54674       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54675     } catch (std::out_of_range& e) {
54676       {
54677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54678       };
54679     } catch (std::exception& e) {
54680       {
54681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54682       };
54683     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54684   }
54685 }
54686
54687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54688   void * jresult ;
54689   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54690
54691   {
54692     try {
54693       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54694     } catch (std::out_of_range& e) {
54695       {
54696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54697       };
54698     } catch (std::exception& e) {
54699       {
54700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54701       };
54702     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54703   }
54704   jresult = (void *)result;
54705   return jresult;
54706 }
54707
54708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54709   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54710
54711   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54712   {
54713     try {
54714       delete arg1;
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54724   }
54725 }
54726
54727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54728   unsigned int jresult ;
54729   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54730   bool result;
54731
54732   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54733   {
54734     try {
54735       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
54736     } catch (std::out_of_range& e) {
54737       {
54738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54739       };
54740     } catch (std::exception& e) {
54741       {
54742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54743       };
54744     } catch (Dali::DaliException e) {
54745       {
54746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54747       };
54748     } catch (...) {
54749       {
54750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54751       };
54752     }
54753   }
54754
54755   jresult = result;
54756   return jresult;
54757 }
54758
54759
54760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54761   unsigned long jresult ;
54762   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54763   std::size_t result;
54764
54765   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54766   {
54767     try {
54768       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *)arg1);
54769     } catch (std::out_of_range& e) {
54770       {
54771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54772       };
54773     } catch (std::exception& e) {
54774       {
54775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54776       };
54777     } catch (Dali::DaliException e) {
54778       {
54779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54780       };
54781     } catch (...) {
54782       {
54783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54784       };
54785     }
54786   }
54787
54788   jresult = (unsigned long)result;
54789   return jresult;
54790 }
54791
54792
54793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54794   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54795   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54796
54797   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54798   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54799   {
54800     try {
54801       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54802     } catch (std::out_of_range& e) {
54803       {
54804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54805       };
54806     } catch (std::exception& e) {
54807       {
54808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54809       };
54810     } catch (Dali::DaliException e) {
54811       {
54812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54813       };
54814     } catch (...) {
54815       {
54816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54817       };
54818     }
54819   }
54820
54821 }
54822
54823
54824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54825   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54826   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54827
54828   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54829   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54830   {
54831     try {
54832       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54833     } catch (std::out_of_range& e) {
54834       {
54835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54836       };
54837     } catch (std::exception& e) {
54838       {
54839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54840       };
54841     } catch (Dali::DaliException e) {
54842       {
54843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54844       };
54845     } catch (...) {
54846       {
54847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54848       };
54849     }
54850   }
54851
54852 }
54853
54854
54855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54856   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54857   Dali::Actor arg2 ;
54858   bool arg3 ;
54859   Dali::DevelActor::VisibilityChange::Type arg4 ;
54860   Dali::Actor *argp2 ;
54861
54862   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54863   argp2 = (Dali::Actor *)jarg2;
54864   if (!argp2) {
54865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54866     return ;
54867   }
54868   arg2 = *argp2;
54869   arg3 = jarg3 ? true : false;
54870   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54871   {
54872     try {
54873       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54874     } catch (std::out_of_range& e) {
54875       {
54876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54877       };
54878     } catch (std::exception& e) {
54879       {
54880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54881       };
54882     } catch (Dali::DaliException e) {
54883       {
54884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54885       };
54886     } catch (...) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54889       };
54890     }
54891   }
54892
54893 }
54894
54895
54896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54897   void * jresult ;
54898   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54899
54900   {
54901     try {
54902       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54903     } catch (std::out_of_range& e) {
54904       {
54905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54906       };
54907     } catch (std::exception& e) {
54908       {
54909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54910       };
54911     } catch (Dali::DaliException e) {
54912       {
54913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54914       };
54915     } catch (...) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54918       };
54919     }
54920   }
54921
54922   jresult = (void *)result;
54923   return jresult;
54924 }
54925
54926
54927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54928   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54929
54930   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54931   {
54932     try {
54933       delete arg1;
54934     } catch (std::out_of_range& e) {
54935       {
54936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54937       };
54938     } catch (std::exception& e) {
54939       {
54940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54941       };
54942     } catch (Dali::DaliException e) {
54943       {
54944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54945       };
54946     } catch (...) {
54947       {
54948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54949       };
54950     }
54951   }
54952
54953 }
54954
54955
54956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54957   void * jresult ;
54958   Dali::Timer *result = 0 ;
54959
54960   {
54961     try {
54962       result = (Dali::Timer *)new Dali::Timer();
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (Dali::DaliException e) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981
54982   jresult = (void *)result;
54983   return jresult;
54984 }
54985
54986
54987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54988   void * jresult ;
54989   unsigned int arg1 ;
54990   Dali::Timer result;
54991
54992   arg1 = (unsigned int)jarg1;
54993   {
54994     try {
54995       result = Dali::Timer::New(arg1);
54996     } catch (std::out_of_range& e) {
54997       {
54998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54999       };
55000     } catch (std::exception& e) {
55001       {
55002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55003       };
55004     } catch (Dali::DaliException e) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55007       };
55008     } catch (...) {
55009       {
55010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55011       };
55012     }
55013   }
55014
55015   jresult = new Dali::Timer((const Dali::Timer &)result);
55016   return jresult;
55017 }
55018
55019
55020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
55021   void * jresult ;
55022   Dali::Timer *arg1 = 0 ;
55023   Dali::Timer *result = 0 ;
55024
55025   arg1 = (Dali::Timer *)jarg1;
55026   if (!arg1) {
55027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55028     return 0;
55029   }
55030   {
55031     try {
55032       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
55033     } catch (std::out_of_range& e) {
55034       {
55035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55036       };
55037     } catch (std::exception& e) {
55038       {
55039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55040       };
55041     } catch (Dali::DaliException e) {
55042       {
55043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55044       };
55045     } catch (...) {
55046       {
55047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55048       };
55049     }
55050   }
55051
55052   jresult = (void *)result;
55053   return jresult;
55054 }
55055
55056
55057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
55058   void * jresult ;
55059   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55060   Dali::Timer *arg2 = 0 ;
55061   Dali::Timer *result = 0 ;
55062
55063   arg1 = (Dali::Timer *)jarg1;
55064   arg2 = (Dali::Timer *)jarg2;
55065   if (!arg2) {
55066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55067     return 0;
55068   }
55069   {
55070     try {
55071       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
55072     } catch (std::out_of_range& e) {
55073       {
55074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (std::exception& e) {
55077       {
55078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (Dali::DaliException e) {
55081       {
55082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55083       };
55084     } catch (...) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55087       };
55088     }
55089   }
55090
55091   jresult = (void *)result;
55092   return jresult;
55093 }
55094
55095
55096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
55097   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55098
55099   arg1 = (Dali::Timer *)jarg1;
55100   {
55101     try {
55102       delete arg1;
55103     } catch (std::out_of_range& e) {
55104       {
55105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55106       };
55107     } catch (std::exception& e) {
55108       {
55109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55110       };
55111     } catch (Dali::DaliException e) {
55112       {
55113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55114       };
55115     } catch (...) {
55116       {
55117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55118       };
55119     }
55120   }
55121
55122 }
55123
55124
55125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
55126   void * jresult ;
55127   Dali::BaseHandle arg1 ;
55128   Dali::BaseHandle *argp1 ;
55129   Dali::Timer result;
55130
55131   argp1 = (Dali::BaseHandle *)jarg1;
55132   if (!argp1) {
55133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
55134     return 0;
55135   }
55136   arg1 = *argp1;
55137   {
55138     try {
55139       result = Dali::Timer::DownCast(arg1);
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55147       };
55148     } catch (Dali::DaliException e) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55151       };
55152     } catch (...) {
55153       {
55154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55155       };
55156     }
55157   }
55158
55159   jresult = new Dali::Timer((const Dali::Timer &)result);
55160   return jresult;
55161 }
55162
55163
55164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
55165   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55166
55167   arg1 = (Dali::Timer *)jarg1;
55168   {
55169     try {
55170       (arg1)->Start();
55171     } catch (std::out_of_range& e) {
55172       {
55173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55174       };
55175     } catch (std::exception& e) {
55176       {
55177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55178       };
55179     } catch (Dali::DaliException e) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55182       };
55183     } catch (...) {
55184       {
55185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55186       };
55187     }
55188   }
55189
55190 }
55191
55192
55193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
55194   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55195
55196   arg1 = (Dali::Timer *)jarg1;
55197   {
55198     try {
55199       (arg1)->Stop();
55200     } catch (std::out_of_range& e) {
55201       {
55202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55203       };
55204     } catch (std::exception& e) {
55205       {
55206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55207       };
55208     } catch (Dali::DaliException e) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55211       };
55212     } catch (...) {
55213       {
55214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55215       };
55216     }
55217   }
55218
55219 }
55220
55221
55222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55223   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55224   unsigned int arg2 ;
55225
55226   arg1 = (Dali::Timer *)jarg1;
55227   arg2 = (unsigned int)jarg2;
55228   {
55229     try {
55230       (arg1)->SetInterval(arg2);
55231     } catch (std::out_of_range& e) {
55232       {
55233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55234       };
55235     } catch (std::exception& e) {
55236       {
55237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55238       };
55239     } catch (Dali::DaliException e) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55242       };
55243     } catch (...) {
55244       {
55245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55246       };
55247     }
55248   }
55249
55250 }
55251
55252
55253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55254   unsigned int jresult ;
55255   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55256   unsigned int result;
55257
55258   arg1 = (Dali::Timer *)jarg1;
55259   {
55260     try {
55261       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55262     } catch (std::out_of_range& e) {
55263       {
55264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55265       };
55266     } catch (std::exception& e) {
55267       {
55268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55269       };
55270     } catch (Dali::DaliException e) {
55271       {
55272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55273       };
55274     } catch (...) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55277       };
55278     }
55279   }
55280
55281   jresult = result;
55282   return jresult;
55283 }
55284
55285
55286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55287   unsigned int jresult ;
55288   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55289   bool result;
55290
55291   arg1 = (Dali::Timer *)jarg1;
55292   {
55293     try {
55294       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
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 (Dali::DaliException e) {
55304       {
55305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55306       };
55307     } catch (...) {
55308       {
55309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55310       };
55311     }
55312   }
55313
55314   jresult = result;
55315   return jresult;
55316 }
55317
55318
55319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55320   void * jresult ;
55321   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55322   Dali::Timer::TimerSignalType *result = 0 ;
55323
55324   arg1 = (Dali::Timer *)jarg1;
55325   {
55326     try {
55327       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55328     } catch (std::out_of_range& e) {
55329       {
55330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55331       };
55332     } catch (std::exception& e) {
55333       {
55334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55335       };
55336     } catch (Dali::DaliException e) {
55337       {
55338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55339       };
55340     } catch (...) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55343       };
55344     }
55345   }
55346
55347   jresult = (void *)result;
55348   return jresult;
55349 }
55350
55351
55352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55353   unsigned int jresult ;
55354   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55355   bool result;
55356
55357   arg1 = (Dali::Signal< bool () > *)jarg1;
55358   {
55359     try {
55360       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55361     } catch (std::out_of_range& e) {
55362       {
55363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55364       };
55365     } catch (std::exception& e) {
55366       {
55367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55368       };
55369     } catch (Dali::DaliException e) {
55370       {
55371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55372       };
55373     } catch (...) {
55374       {
55375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55376       };
55377     }
55378   }
55379
55380   jresult = result;
55381   return jresult;
55382 }
55383
55384
55385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55386   unsigned long jresult ;
55387   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55388   std::size_t result;
55389
55390   arg1 = (Dali::Signal< bool () > *)jarg1;
55391   {
55392     try {
55393       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55394     } catch (std::out_of_range& e) {
55395       {
55396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55397       };
55398     } catch (std::exception& e) {
55399       {
55400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55401       };
55402     } catch (Dali::DaliException e) {
55403       {
55404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55405       };
55406     } catch (...) {
55407       {
55408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55409       };
55410     }
55411   }
55412
55413   jresult = (unsigned long)result;
55414   return jresult;
55415 }
55416
55417
55418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55419   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55420   bool (*arg2)() = (bool (*)()) 0 ;
55421
55422   arg1 = (Dali::Signal< bool () > *)jarg1;
55423   arg2 = (bool (*)())jarg2;
55424   {
55425     try {
55426       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55427     } catch (std::out_of_range& e) {
55428       {
55429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55430       };
55431     } catch (std::exception& e) {
55432       {
55433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55434       };
55435     } catch (Dali::DaliException e) {
55436       {
55437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55438       };
55439     } catch (...) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55442       };
55443     }
55444   }
55445
55446 }
55447
55448
55449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55450   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55451   bool (*arg2)() = (bool (*)()) 0 ;
55452
55453   arg1 = (Dali::Signal< bool () > *)jarg1;
55454   arg2 = (bool (*)())jarg2;
55455   {
55456     try {
55457       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55458     } catch (std::out_of_range& e) {
55459       {
55460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55461       };
55462     } catch (std::exception& e) {
55463       {
55464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55465       };
55466     } catch (Dali::DaliException e) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55469       };
55470     } catch (...) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55473       };
55474     }
55475   }
55476
55477 }
55478
55479
55480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55481   unsigned int jresult ;
55482   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55483   bool result;
55484
55485   arg1 = (Dali::Signal< bool () > *)jarg1;
55486   {
55487     try {
55488       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55489     } catch (std::out_of_range& e) {
55490       {
55491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55492       };
55493     } catch (std::exception& e) {
55494       {
55495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55496       };
55497     } catch (Dali::DaliException e) {
55498       {
55499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55500       };
55501     } catch (...) {
55502       {
55503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55504       };
55505     }
55506   }
55507
55508   jresult = result;
55509   return jresult;
55510 }
55511
55512
55513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55514   void * jresult ;
55515   Dali::Signal< bool () > *result = 0 ;
55516
55517   {
55518     try {
55519       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55527       };
55528     } catch (Dali::DaliException e) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55531       };
55532     } catch (...) {
55533       {
55534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55535       };
55536     }
55537   }
55538
55539   jresult = (void *)result;
55540   return jresult;
55541 }
55542
55543
55544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55545   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55546
55547   arg1 = (Dali::Signal< bool () > *)jarg1;
55548   {
55549     try {
55550       delete arg1;
55551     } catch (std::out_of_range& e) {
55552       {
55553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55554       };
55555     } catch (std::exception& e) {
55556       {
55557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55558       };
55559     } catch (Dali::DaliException e) {
55560       {
55561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55562       };
55563     } catch (...) {
55564       {
55565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55566       };
55567     }
55568   }
55569
55570 }
55571
55572
55573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55574   int jresult ;
55575   int result;
55576
55577   {
55578     try {
55579       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55580     } catch (std::out_of_range& e) {
55581       {
55582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55583       };
55584     } catch (std::exception& e) {
55585       {
55586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55587       };
55588     } catch (Dali::DaliException e) {
55589       {
55590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55591       };
55592     } catch (...) {
55593       {
55594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55595       };
55596     }
55597   }
55598
55599   jresult = (int)result;
55600   return jresult;
55601 }
55602
55603
55604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55605   int jresult ;
55606   int result;
55607
55608   {
55609     try {
55610       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55611     } catch (std::out_of_range& e) {
55612       {
55613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (std::exception& e) {
55616       {
55617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55618       };
55619     } catch (Dali::DaliException e) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55622       };
55623     } catch (...) {
55624       {
55625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55626       };
55627     }
55628   }
55629
55630   jresult = (int)result;
55631   return jresult;
55632 }
55633
55634
55635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55636   int jresult ;
55637   int result;
55638
55639   {
55640     try {
55641       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55642     } catch (std::out_of_range& e) {
55643       {
55644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55645       };
55646     } catch (std::exception& e) {
55647       {
55648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55649       };
55650     } catch (Dali::DaliException e) {
55651       {
55652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55653       };
55654     } catch (...) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55657       };
55658     }
55659   }
55660
55661   jresult = (int)result;
55662   return jresult;
55663 }
55664
55665
55666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55667   int jresult ;
55668   int result;
55669
55670   {
55671     try {
55672       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55673     } catch (std::out_of_range& e) {
55674       {
55675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55676       };
55677     } catch (std::exception& e) {
55678       {
55679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55680       };
55681     } catch (Dali::DaliException e) {
55682       {
55683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55684       };
55685     } catch (...) {
55686       {
55687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55688       };
55689     }
55690   }
55691
55692   jresult = (int)result;
55693   return jresult;
55694 }
55695
55696
55697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55698   int jresult ;
55699   int result;
55700
55701   {
55702     try {
55703       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55704     } catch (std::out_of_range& e) {
55705       {
55706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55707       };
55708     } catch (std::exception& e) {
55709       {
55710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55711       };
55712     } catch (Dali::DaliException e) {
55713       {
55714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55715       };
55716     } catch (...) {
55717       {
55718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55719       };
55720     }
55721   }
55722
55723   jresult = (int)result;
55724   return jresult;
55725 }
55726
55727
55728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55729   int jresult ;
55730   int result;
55731
55732   {
55733     try {
55734       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (Dali::DaliException e) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55746       };
55747     } catch (...) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55750       };
55751     }
55752   }
55753
55754   jresult = (int)result;
55755   return jresult;
55756 }
55757
55758
55759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55760   int jresult ;
55761   int result;
55762
55763   {
55764     try {
55765       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55766     } catch (std::out_of_range& e) {
55767       {
55768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55769       };
55770     } catch (std::exception& e) {
55771       {
55772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (Dali::DaliException e) {
55775       {
55776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55777       };
55778     } catch (...) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55781       };
55782     }
55783   }
55784
55785   jresult = (int)result;
55786   return jresult;
55787 }
55788
55789
55790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55791   int jresult ;
55792   int result;
55793
55794   {
55795     try {
55796       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55797     } catch (std::out_of_range& e) {
55798       {
55799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (std::exception& e) {
55802       {
55803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55804       };
55805     } catch (Dali::DaliException e) {
55806       {
55807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55808       };
55809     } catch (...) {
55810       {
55811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55812       };
55813     }
55814   }
55815
55816   jresult = (int)result;
55817   return jresult;
55818 }
55819
55820
55821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55822   int jresult ;
55823   int result;
55824
55825   {
55826     try {
55827       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55828     } catch (std::out_of_range& e) {
55829       {
55830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55831       };
55832     } catch (std::exception& e) {
55833       {
55834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55835       };
55836     } catch (Dali::DaliException e) {
55837       {
55838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55839       };
55840     } catch (...) {
55841       {
55842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55843       };
55844     }
55845   }
55846
55847   jresult = (int)result;
55848   return jresult;
55849 }
55850
55851
55852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55853   int jresult ;
55854   int result;
55855
55856   {
55857     try {
55858       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55859     } catch (std::out_of_range& e) {
55860       {
55861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55862       };
55863     } catch (std::exception& e) {
55864       {
55865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55866       };
55867     } catch (Dali::DaliException e) {
55868       {
55869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55870       };
55871     } catch (...) {
55872       {
55873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55874       };
55875     }
55876   }
55877
55878   jresult = (int)result;
55879   return jresult;
55880 }
55881
55882
55883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55884   int jresult ;
55885   int result;
55886
55887   {
55888     try {
55889       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55890     } catch (std::out_of_range& e) {
55891       {
55892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55893       };
55894     } catch (std::exception& e) {
55895       {
55896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55897       };
55898     } catch (Dali::DaliException e) {
55899       {
55900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55901       };
55902     } catch (...) {
55903       {
55904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55905       };
55906     }
55907   }
55908
55909   jresult = (int)result;
55910   return jresult;
55911 }
55912
55913
55914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55915   int jresult ;
55916   int result;
55917
55918   {
55919     try {
55920       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55921     } catch (std::out_of_range& e) {
55922       {
55923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55924       };
55925     } catch (std::exception& e) {
55926       {
55927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55928       };
55929     } catch (Dali::DaliException e) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55932       };
55933     } catch (...) {
55934       {
55935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55936       };
55937     }
55938   }
55939
55940   jresult = (int)result;
55941   return jresult;
55942 }
55943
55944
55945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55946   int jresult ;
55947   int result;
55948
55949   {
55950     try {
55951       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55952     } catch (std::out_of_range& e) {
55953       {
55954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55955       };
55956     } catch (std::exception& e) {
55957       {
55958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55959       };
55960     } catch (Dali::DaliException e) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55963       };
55964     } catch (...) {
55965       {
55966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55967       };
55968     }
55969   }
55970
55971   jresult = (int)result;
55972   return jresult;
55973 }
55974
55975
55976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55977   int jresult ;
55978   int result;
55979
55980   {
55981     try {
55982       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55983     } catch (std::out_of_range& e) {
55984       {
55985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55986       };
55987     } catch (std::exception& e) {
55988       {
55989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55990       };
55991     } catch (Dali::DaliException e) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55994       };
55995     } catch (...) {
55996       {
55997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55998       };
55999     }
56000   }
56001
56002   jresult = (int)result;
56003   return jresult;
56004 }
56005
56006
56007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56008   int jresult ;
56009   int result;
56010
56011   {
56012     try {
56013       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56014     } catch (std::out_of_range& e) {
56015       {
56016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56017       };
56018     } catch (std::exception& e) {
56019       {
56020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56021       };
56022     } catch (Dali::DaliException e) {
56023       {
56024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56025       };
56026     } catch (...) {
56027       {
56028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56029       };
56030     }
56031   }
56032
56033   jresult = (int)result;
56034   return jresult;
56035 }
56036
56037
56038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56039   int jresult ;
56040   int result;
56041
56042   {
56043     try {
56044       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (Dali::DaliException e) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56060       };
56061     }
56062   }
56063
56064   jresult = (int)result;
56065   return jresult;
56066 }
56067
56068
56069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56070   int jresult ;
56071   int result;
56072
56073   {
56074     try {
56075       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (Dali::DaliException e) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56091       };
56092     }
56093   }
56094
56095   jresult = (int)result;
56096   return jresult;
56097 }
56098
56099
56100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56101   int jresult ;
56102   int result;
56103
56104   {
56105     try {
56106       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56107     } catch (std::out_of_range& e) {
56108       {
56109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56110       };
56111     } catch (std::exception& e) {
56112       {
56113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56114       };
56115     } catch (Dali::DaliException e) {
56116       {
56117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56118       };
56119     } catch (...) {
56120       {
56121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56122       };
56123     }
56124   }
56125
56126   jresult = (int)result;
56127   return jresult;
56128 }
56129
56130
56131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56132   int jresult ;
56133   int result;
56134
56135   {
56136     try {
56137       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56138     } catch (std::out_of_range& e) {
56139       {
56140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56141       };
56142     } catch (std::exception& e) {
56143       {
56144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (Dali::DaliException e) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56149       };
56150     } catch (...) {
56151       {
56152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56153       };
56154     }
56155   }
56156
56157   jresult = (int)result;
56158   return jresult;
56159 }
56160
56161
56162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56163   int jresult ;
56164   int result;
56165
56166   {
56167     try {
56168       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56169     } catch (std::out_of_range& e) {
56170       {
56171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56172       };
56173     } catch (std::exception& e) {
56174       {
56175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (Dali::DaliException e) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56180       };
56181     } catch (...) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56184       };
56185     }
56186   }
56187
56188   jresult = (int)result;
56189   return jresult;
56190 }
56191
56192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
56193   int jresult ;
56194   int result;
56195
56196   {
56197     try {
56198       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
56199     } catch (std::out_of_range& e) {
56200       {
56201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56202       };
56203     } catch (std::exception& e) {
56204       {
56205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56206       };
56207     } catch (Dali::DaliException e) {
56208       {
56209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56210       };
56211     } catch (...) {
56212       {
56213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56214       };
56215     }
56216   }
56217
56218   jresult = (int)result;
56219   return jresult;
56220 }
56221
56222
56223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56224   int jresult ;
56225   int result;
56226   {
56227     try
56228     {
56229       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56230     } catch (std::out_of_range& e) {
56231       {
56232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56233       };
56234     } catch (std::exception& e) {
56235       {
56236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (Dali::DaliException e) {
56239       {
56240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248
56249   jresult = (int)result;
56250   return jresult;
56251 }
56252
56253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56254   int jresult ;
56255   int result;
56256   {
56257     try
56258     {
56259       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56260     } catch (std::out_of_range& e) {
56261       {
56262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56263       };
56264     } catch (std::exception& e) {
56265       {
56266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56267       };
56268     } catch (Dali::DaliException e) {
56269       {
56270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56271       };
56272     } catch (...) {
56273       {
56274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56275       };
56276     }
56277   }
56278
56279   jresult = (int)result;
56280   return jresult;
56281 }
56282
56283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56284   int jresult ;
56285   int result;
56286   {
56287     try
56288     {
56289       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56290     } catch (std::out_of_range& e) {
56291       {
56292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (std::exception& e) {
56295       {
56296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56297       };
56298     } catch (Dali::DaliException e) {
56299       {
56300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56301       };
56302     } catch (...) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56305       };
56306     }
56307   }
56308
56309   jresult = (int)result;
56310   return jresult;
56311 }
56312
56313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56314   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56315 }
56316
56317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56318   int jresult ;
56319   int result;
56320   {
56321     try
56322     {
56323       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56324     } catch (std::out_of_range& e) {
56325       {
56326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56327       };
56328     } catch (std::exception& e) {
56329       {
56330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56331       };
56332     } catch (Dali::DaliException e) {
56333       {
56334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56335       };
56336     } catch (...) {
56337       {
56338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56339       };
56340     }
56341   }
56342
56343   jresult = (int)result;
56344   return jresult;
56345 }
56346
56347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56348   int jresult ;
56349   int result;
56350   {
56351     try
56352     {
56353       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56354     } catch (std::out_of_range& e) {
56355       {
56356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56357       };
56358     } catch (std::exception& e) {
56359       {
56360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56361       };
56362     } catch (Dali::DaliException e) {
56363       {
56364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56365       };
56366     } catch (...) {
56367       {
56368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56369       };
56370     }
56371   }
56372
56373   jresult = (int)result;
56374   return jresult;
56375 }
56376
56377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56378   int jresult ;
56379   int result;
56380
56381   {
56382     try {
56383       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56384     } catch (std::out_of_range& e) {
56385       {
56386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56387       };
56388     } catch (std::exception& e) {
56389       {
56390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56391       };
56392     } catch (Dali::DaliException e) {
56393       {
56394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56395       };
56396     } catch (...) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56399       };
56400     }
56401   }
56402
56403   jresult = (int)result;
56404   return jresult;
56405 }
56406
56407
56408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56409   int jresult ;
56410   int result;
56411
56412   {
56413     try {
56414       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56415     } catch (std::out_of_range& e) {
56416       {
56417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56418       };
56419     } catch (std::exception& e) {
56420       {
56421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56422       };
56423     } catch (Dali::DaliException e) {
56424       {
56425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56426       };
56427     } catch (...) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56430       };
56431     }
56432   }
56433
56434   jresult = (int)result;
56435   return jresult;
56436 }
56437
56438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56439   int jresult ;
56440   int result;
56441   {
56442     try
56443     {
56444       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56445     } catch (std::out_of_range& e) {
56446       {
56447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56448       };
56449     } catch (std::exception& e) {
56450       {
56451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56452       };
56453     } catch (...) {
56454       {
56455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56456       };
56457     }
56458   }
56459   jresult = (int)result;
56460   return jresult;
56461 }
56462
56463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56464   int jresult ;
56465   int result;
56466   {
56467     try
56468     {
56469       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56470     } catch (std::out_of_range& e) {
56471       {
56472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56473       };
56474     } catch (std::exception& e) {
56475       {
56476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56477       };
56478     } catch (...) {
56479       {
56480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56481       };
56482     }
56483   }
56484   jresult = (int)result;
56485   return jresult;
56486 }
56487
56488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56489   int jresult ;
56490   int result;
56491   {
56492     try
56493     {
56494       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56495     } catch (std::out_of_range& e) {
56496       {
56497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (std::exception& e) {
56500       {
56501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56502       };
56503     } catch (...) {
56504       {
56505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56506       };
56507     }
56508   }
56509   jresult = (int)result;
56510   return jresult;
56511 }
56512
56513
56514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56515   int jresult ;
56516   int result;
56517   {
56518     try
56519     {
56520       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
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 = (int)result;
56536   return jresult;
56537 }
56538
56539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56540   int jresult ;
56541   int result;
56542   {
56543     try
56544     {
56545       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56546     } catch (std::out_of_range& e) {
56547       {
56548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (std::exception& e) {
56551       {
56552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56553       };
56554     } catch (...) {
56555       {
56556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56557       };
56558     }
56559   }
56560   jresult = (int)result;
56561   return jresult;
56562 }
56563
56564
56565
56566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56567   int jresult ;
56568   int result;
56569
56570   {
56571     try {
56572       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56573     } catch (std::out_of_range& e) {
56574       {
56575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (std::exception& e) {
56578       {
56579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56580       };
56581     } catch (Dali::DaliException e) {
56582       {
56583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56584       };
56585     } catch (...) {
56586       {
56587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56588       };
56589     }
56590   }
56591
56592   jresult = (int)result;
56593   return jresult;
56594 }
56595
56596
56597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56598   int jresult ;
56599   int result;
56600
56601   {
56602     try {
56603       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56604     } catch (std::out_of_range& e) {
56605       {
56606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56607       };
56608     } catch (std::exception& e) {
56609       {
56610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56611       };
56612     } catch (Dali::DaliException e) {
56613       {
56614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56615       };
56616     } catch (...) {
56617       {
56618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56619       };
56620     }
56621   }
56622
56623   jresult = (int)result;
56624   return jresult;
56625 }
56626
56627
56628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56629   int jresult ;
56630   int result;
56631
56632   {
56633     try {
56634       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56635     } catch (std::out_of_range& e) {
56636       {
56637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56638       };
56639     } catch (std::exception& e) {
56640       {
56641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56642       };
56643     } catch (Dali::DaliException e) {
56644       {
56645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56646       };
56647     } catch (...) {
56648       {
56649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56650       };
56651     }
56652   }
56653
56654   jresult = (int)result;
56655   return jresult;
56656 }
56657
56658
56659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56660   int jresult ;
56661   int result;
56662
56663   {
56664     try {
56665       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56666     } catch (std::out_of_range& e) {
56667       {
56668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56669       };
56670     } catch (std::exception& e) {
56671       {
56672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56673       };
56674     } catch (Dali::DaliException e) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56677       };
56678     } catch (...) {
56679       {
56680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56681       };
56682     }
56683   }
56684
56685   jresult = (int)result;
56686   return jresult;
56687 }
56688
56689
56690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56691   int jresult ;
56692   int result;
56693
56694   {
56695     try {
56696       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56697     } catch (std::out_of_range& e) {
56698       {
56699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (std::exception& e) {
56702       {
56703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56704       };
56705     } catch (Dali::DaliException e) {
56706       {
56707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56708       };
56709     } catch (...) {
56710       {
56711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56712       };
56713     }
56714   }
56715
56716   jresult = (int)result;
56717   return jresult;
56718 }
56719
56720
56721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56722   int jresult ;
56723   int result;
56724
56725   {
56726     try {
56727       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56728     } catch (std::out_of_range& e) {
56729       {
56730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56731       };
56732     } catch (std::exception& e) {
56733       {
56734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56735       };
56736     } catch (Dali::DaliException e) {
56737       {
56738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56739       };
56740     } catch (...) {
56741       {
56742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56743       };
56744     }
56745   }
56746
56747   jresult = (int)result;
56748   return jresult;
56749 }
56750
56751
56752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56753   int jresult ;
56754   int result;
56755
56756   {
56757     try {
56758       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56759     } catch (std::out_of_range& e) {
56760       {
56761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56762       };
56763     } catch (std::exception& e) {
56764       {
56765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56766       };
56767     } catch (Dali::DaliException e) {
56768       {
56769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56770       };
56771     } catch (...) {
56772       {
56773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56774       };
56775     }
56776   }
56777
56778   jresult = (int)result;
56779   return jresult;
56780 }
56781
56782 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56783   int jresult ;
56784   int result;
56785
56786   {
56787     try {
56788       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56789     } catch (std::out_of_range& e) {
56790       {
56791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56792       };
56793     } catch (std::exception& e) {
56794       {
56795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56796       };
56797     } catch (...) {
56798       {
56799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56800       };
56801     }
56802   }
56803   jresult = (int)result;
56804   return jresult;
56805 }
56806
56807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56808   int jresult ;
56809   int result;
56810
56811   {
56812     try {
56813       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56814     } catch (std::out_of_range& e) {
56815       {
56816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56817       };
56818     } catch (std::exception& e) {
56819       {
56820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56821       };
56822     } catch (Dali::DaliException e) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56825       };
56826     } catch (...) {
56827       {
56828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56829       };
56830     }
56831   }
56832
56833   jresult = (int)result;
56834   return jresult;
56835 }
56836
56837
56838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56839   int jresult ;
56840   int result;
56841
56842   {
56843     try {
56844       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56845     } catch (std::out_of_range& e) {
56846       {
56847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56848       };
56849     } catch (std::exception& e) {
56850       {
56851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56852       };
56853     } catch (Dali::DaliException e) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56856       };
56857     } catch (...) {
56858       {
56859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56860       };
56861     }
56862   }
56863
56864   jresult = (int)result;
56865   return jresult;
56866 }
56867
56868
56869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56870   int jresult ;
56871   int result;
56872
56873   {
56874     try {
56875       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56876     } catch (std::out_of_range& e) {
56877       {
56878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56879       };
56880     } catch (std::exception& e) {
56881       {
56882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56883       };
56884     } catch (Dali::DaliException e) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56887       };
56888     } catch (...) {
56889       {
56890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56891       };
56892     }
56893   }
56894
56895   jresult = (int)result;
56896   return jresult;
56897 }
56898
56899
56900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56901   int jresult ;
56902   int result;
56903
56904   {
56905     try {
56906       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56907     } catch (std::out_of_range& e) {
56908       {
56909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56910       };
56911     } catch (std::exception& e) {
56912       {
56913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (Dali::DaliException e) {
56916       {
56917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56918       };
56919     } catch (...) {
56920       {
56921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56922       };
56923     }
56924   }
56925
56926   jresult = (int)result;
56927   return jresult;
56928 }
56929
56930
56931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56932   int jresult ;
56933   int result;
56934
56935   {
56936     try {
56937       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56938     } catch (std::out_of_range& e) {
56939       {
56940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56941       };
56942     } catch (std::exception& e) {
56943       {
56944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56945       };
56946     } catch (Dali::DaliException e) {
56947       {
56948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56949       };
56950     } catch (...) {
56951       {
56952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56953       };
56954     }
56955   }
56956
56957   jresult = (int)result;
56958   return jresult;
56959 }
56960
56961
56962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56963   int jresult ;
56964   int result;
56965
56966   {
56967     try {
56968       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56969     } catch (std::out_of_range& e) {
56970       {
56971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56972       };
56973     } catch (std::exception& e) {
56974       {
56975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56976       };
56977     } catch (Dali::DaliException e) {
56978       {
56979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56980       };
56981     } catch (...) {
56982       {
56983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56984       };
56985     }
56986   }
56987
56988   jresult = (int)result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56994   int jresult ;
56995   int result;
56996
56997   {
56998     try {
56999       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (Dali::DaliException e) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57015       };
57016     }
57017   }
57018
57019   jresult = (int)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57025   int jresult ;
57026   int result;
57027
57028   {
57029     try {
57030       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57031     } catch (std::out_of_range& e) {
57032       {
57033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (std::exception& e) {
57036       {
57037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57038       };
57039     } catch (Dali::DaliException e) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57042       };
57043     } catch (...) {
57044       {
57045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57046       };
57047     }
57048   }
57049
57050   jresult = (int)result;
57051   return jresult;
57052 }
57053
57054
57055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57056   int jresult ;
57057   int result;
57058
57059   {
57060     try {
57061       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57062     } catch (std::out_of_range& e) {
57063       {
57064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (std::exception& e) {
57067       {
57068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57069       };
57070     } catch (Dali::DaliException e) {
57071       {
57072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57077       };
57078     }
57079   }
57080
57081   jresult = (int)result;
57082   return jresult;
57083 }
57084
57085
57086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57087   int jresult ;
57088   int result;
57089
57090   {
57091     try {
57092       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57093     } catch (std::out_of_range& e) {
57094       {
57095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57096       };
57097     } catch (std::exception& e) {
57098       {
57099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57100       };
57101     } catch (Dali::DaliException e) {
57102       {
57103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57104       };
57105     } catch (...) {
57106       {
57107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57108       };
57109     }
57110   }
57111
57112   jresult = (int)result;
57113   return jresult;
57114 }
57115
57116
57117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57118   int jresult ;
57119   int result;
57120
57121   {
57122     try {
57123       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57124     } catch (std::out_of_range& e) {
57125       {
57126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57127       };
57128     } catch (std::exception& e) {
57129       {
57130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57131       };
57132     } catch (Dali::DaliException e) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57135       };
57136     } catch (...) {
57137       {
57138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57139       };
57140     }
57141   }
57142
57143   jresult = (int)result;
57144   return jresult;
57145 }
57146
57147
57148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57149   int jresult ;
57150   int result;
57151
57152   {
57153     try {
57154       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
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 (Dali::DaliException e) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57166       };
57167     } catch (...) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57170       };
57171     }
57172   }
57173
57174   jresult = (int)result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57180   int jresult ;
57181   int result;
57182
57183   {
57184     try {
57185       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57193       };
57194     } catch (Dali::DaliException e) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57197       };
57198     } catch (...) {
57199       {
57200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57201       };
57202     }
57203   }
57204
57205   jresult = (int)result;
57206   return jresult;
57207 }
57208
57209
57210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57211   int jresult ;
57212   int result;
57213
57214   {
57215     try {
57216       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57217     } catch (std::out_of_range& e) {
57218       {
57219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57220       };
57221     } catch (std::exception& e) {
57222       {
57223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57224       };
57225     } catch (Dali::DaliException e) {
57226       {
57227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57228       };
57229     } catch (...) {
57230       {
57231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57232       };
57233     }
57234   }
57235
57236   jresult = (int)result;
57237   return jresult;
57238 }
57239
57240
57241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57242   int jresult ;
57243   int result;
57244
57245   {
57246     try {
57247       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57248     } catch (std::out_of_range& e) {
57249       {
57250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57251       };
57252     } catch (std::exception& e) {
57253       {
57254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57255       };
57256     } catch (Dali::DaliException e) {
57257       {
57258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57259       };
57260     } catch (...) {
57261       {
57262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57263       };
57264     }
57265   }
57266
57267   jresult = (int)result;
57268   return jresult;
57269 }
57270
57271
57272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57273   int jresult ;
57274   int result;
57275
57276   {
57277     try {
57278       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57279     } catch (std::out_of_range& e) {
57280       {
57281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57282       };
57283     } catch (std::exception& e) {
57284       {
57285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57286       };
57287     } catch (Dali::DaliException e) {
57288       {
57289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57290       };
57291     } catch (...) {
57292       {
57293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57294       };
57295     }
57296   }
57297
57298   jresult = (int)result;
57299   return jresult;
57300 }
57301
57302
57303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57304   int jresult ;
57305   int result;
57306
57307   {
57308     try {
57309       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57310     } catch (std::out_of_range& e) {
57311       {
57312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57313       };
57314     } catch (std::exception& e) {
57315       {
57316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57317       };
57318     } catch (Dali::DaliException e) {
57319       {
57320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57321       };
57322     } catch (...) {
57323       {
57324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57325       };
57326     }
57327   }
57328
57329   jresult = (int)result;
57330   return jresult;
57331 }
57332
57333
57334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57335   int jresult ;
57336   int result;
57337
57338   {
57339     try {
57340       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57341     } catch (std::out_of_range& e) {
57342       {
57343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57344       };
57345     } catch (std::exception& e) {
57346       {
57347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57348       };
57349     } catch (Dali::DaliException e) {
57350       {
57351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57352       };
57353     } catch (...) {
57354       {
57355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57356       };
57357     }
57358   }
57359
57360   jresult = (int)result;
57361   return jresult;
57362 }
57363
57364
57365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57366   int jresult ;
57367   int result;
57368
57369   {
57370     try {
57371       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57372     } catch (std::out_of_range& e) {
57373       {
57374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57375       };
57376     } catch (std::exception& e) {
57377       {
57378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57379       };
57380     } catch (Dali::DaliException e) {
57381       {
57382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57383       };
57384     } catch (...) {
57385       {
57386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57387       };
57388     }
57389   }
57390
57391   jresult = (int)result;
57392   return jresult;
57393 }
57394
57395
57396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57397   int jresult ;
57398   int result;
57399
57400   {
57401     try {
57402       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57403     } catch (std::out_of_range& e) {
57404       {
57405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57406       };
57407     } catch (std::exception& e) {
57408       {
57409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57410       };
57411     } catch (Dali::DaliException e) {
57412       {
57413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57414       };
57415     } catch (...) {
57416       {
57417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57418       };
57419     }
57420   }
57421
57422   jresult = (int)result;
57423   return jresult;
57424 }
57425
57426
57427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57428   int jresult ;
57429   int result;
57430
57431   {
57432     try {
57433       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57434     } catch (std::out_of_range& e) {
57435       {
57436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57437       };
57438     } catch (std::exception& e) {
57439       {
57440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57441       };
57442     } catch (Dali::DaliException e) {
57443       {
57444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57445       };
57446     } catch (...) {
57447       {
57448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57449       };
57450     }
57451   }
57452
57453   jresult = (int)result;
57454   return jresult;
57455 }
57456
57457
57458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57459   int jresult ;
57460   int result;
57461
57462   {
57463     try {
57464       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57465     } catch (std::out_of_range& e) {
57466       {
57467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57468       };
57469     } catch (std::exception& e) {
57470       {
57471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57472       };
57473     } catch (Dali::DaliException e) {
57474       {
57475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57476       };
57477     } catch (...) {
57478       {
57479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57480       };
57481     }
57482   }
57483
57484   jresult = (int)result;
57485   return jresult;
57486 }
57487
57488
57489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57490   int jresult ;
57491   int result;
57492
57493   {
57494     try {
57495       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57496     } catch (std::out_of_range& e) {
57497       {
57498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57499       };
57500     } catch (std::exception& e) {
57501       {
57502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57503       };
57504     } catch (Dali::DaliException e) {
57505       {
57506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57507       };
57508     } catch (...) {
57509       {
57510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57511       };
57512     }
57513   }
57514
57515   jresult = (int)result;
57516   return jresult;
57517 }
57518
57519
57520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57521   int jresult ;
57522   int result;
57523
57524   {
57525     try {
57526       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57527     } catch (std::out_of_range& e) {
57528       {
57529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57530       };
57531     } catch (std::exception& e) {
57532       {
57533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57534       };
57535     } catch (Dali::DaliException e) {
57536       {
57537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57538       };
57539     } catch (...) {
57540       {
57541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57542       };
57543     }
57544   }
57545
57546   jresult = (int)result;
57547   return jresult;
57548 }
57549
57550
57551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57552   int jresult ;
57553   int result;
57554
57555   {
57556     try {
57557       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57558     } catch (std::out_of_range& e) {
57559       {
57560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57561       };
57562     } catch (std::exception& e) {
57563       {
57564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57565       };
57566     } catch (Dali::DaliException e) {
57567       {
57568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57569       };
57570     } catch (...) {
57571       {
57572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57573       };
57574     }
57575   }
57576
57577   jresult = (int)result;
57578   return jresult;
57579 }
57580
57581
57582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57583   int jresult ;
57584   int result;
57585
57586   {
57587     try {
57588       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57589     } catch (std::out_of_range& e) {
57590       {
57591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57592       };
57593     } catch (std::exception& e) {
57594       {
57595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57596       };
57597     } catch (Dali::DaliException e) {
57598       {
57599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57604       };
57605     }
57606   }
57607
57608   jresult = (int)result;
57609   return jresult;
57610 }
57611
57612
57613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57614   int jresult ;
57615   int result;
57616
57617   {
57618     try {
57619       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (Dali::DaliException e) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57635       };
57636     }
57637   }
57638
57639   jresult = (int)result;
57640   return jresult;
57641 }
57642
57643
57644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57645   int jresult ;
57646   int result;
57647
57648   {
57649     try {
57650       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57651     } catch (std::out_of_range& e) {
57652       {
57653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57654       };
57655     } catch (std::exception& e) {
57656       {
57657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57658       };
57659     } catch (Dali::DaliException e) {
57660       {
57661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57662       };
57663     } catch (...) {
57664       {
57665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57666       };
57667     }
57668   }
57669
57670   jresult = (int)result;
57671   return jresult;
57672 }
57673
57674
57675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57676   void * jresult ;
57677   Dali::Toolkit::Builder *result = 0 ;
57678
57679   {
57680     try {
57681       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57682     } catch (std::out_of_range& e) {
57683       {
57684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57685       };
57686     } catch (std::exception& e) {
57687       {
57688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57689       };
57690     } catch (Dali::DaliException e) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57693       };
57694     } catch (...) {
57695       {
57696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57697       };
57698     }
57699   }
57700
57701   jresult = (void *)result;
57702   return jresult;
57703 }
57704
57705
57706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57707   void * jresult ;
57708   Dali::Toolkit::Builder result;
57709
57710   {
57711     try {
57712       result = Dali::Toolkit::Builder::New();
57713     } catch (std::out_of_range& e) {
57714       {
57715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57716       };
57717     } catch (std::exception& e) {
57718       {
57719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57720       };
57721     } catch (Dali::DaliException e) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57724       };
57725     } catch (...) {
57726       {
57727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57728       };
57729     }
57730   }
57731
57732   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57733   return jresult;
57734 }
57735
57736
57737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57738   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57739
57740   arg1 = (Dali::Toolkit::Builder *)jarg1;
57741   {
57742     try {
57743       delete arg1;
57744     } catch (std::out_of_range& e) {
57745       {
57746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57747       };
57748     } catch (std::exception& e) {
57749       {
57750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57751       };
57752     } catch (Dali::DaliException e) {
57753       {
57754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57755       };
57756     } catch (...) {
57757       {
57758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57759       };
57760     }
57761   }
57762
57763 }
57764
57765
57766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57767   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57768   std::string *arg2 = 0 ;
57769   Dali::Toolkit::Builder::UIFormat arg3 ;
57770
57771   arg1 = (Dali::Toolkit::Builder *)jarg1;
57772   if (!jarg2) {
57773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57774     return ;
57775   }
57776   std::string arg2_str(jarg2);
57777   arg2 = &arg2_str;
57778   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57779   {
57780     try {
57781       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57782     } catch (std::out_of_range& e) {
57783       {
57784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57785       };
57786     } catch (std::exception& e) {
57787       {
57788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57789       };
57790     } catch (Dali::DaliException e) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57793       };
57794     } catch (...) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57797       };
57798     }
57799   }
57800
57801
57802   //argout typemap for const std::string&
57803
57804 }
57805
57806
57807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57808   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57809   std::string *arg2 = 0 ;
57810
57811   arg1 = (Dali::Toolkit::Builder *)jarg1;
57812   if (!jarg2) {
57813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57814     return ;
57815   }
57816   std::string arg2_str(jarg2);
57817   arg2 = &arg2_str;
57818   {
57819     try {
57820       (arg1)->LoadFromString((std::string const &)*arg2);
57821     } catch (std::out_of_range& e) {
57822       {
57823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57824       };
57825     } catch (std::exception& e) {
57826       {
57827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57828       };
57829     } catch (Dali::DaliException e) {
57830       {
57831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57832       };
57833     } catch (...) {
57834       {
57835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57836       };
57837     }
57838   }
57839
57840
57841   //argout typemap for const std::string&
57842
57843 }
57844
57845
57846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57847   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57848   Dali::Property::Map *arg2 = 0 ;
57849
57850   arg1 = (Dali::Toolkit::Builder *)jarg1;
57851   arg2 = (Dali::Property::Map *)jarg2;
57852   if (!arg2) {
57853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57854     return ;
57855   }
57856   {
57857     try {
57858       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57859     } catch (std::out_of_range& e) {
57860       {
57861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57862       };
57863     } catch (std::exception& e) {
57864       {
57865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57866       };
57867     } catch (Dali::DaliException e) {
57868       {
57869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57870       };
57871     } catch (...) {
57872       {
57873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57874       };
57875     }
57876   }
57877
57878 }
57879
57880
57881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57882   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57883   std::string *arg2 = 0 ;
57884   Dali::Property::Value *arg3 = 0 ;
57885
57886   arg1 = (Dali::Toolkit::Builder *)jarg1;
57887   if (!jarg2) {
57888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57889     return ;
57890   }
57891   std::string arg2_str(jarg2);
57892   arg2 = &arg2_str;
57893   arg3 = (Dali::Property::Value *)jarg3;
57894   if (!arg3) {
57895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57896     return ;
57897   }
57898   {
57899     try {
57900       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57901     } catch (std::out_of_range& e) {
57902       {
57903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57904       };
57905     } catch (std::exception& e) {
57906       {
57907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57908       };
57909     } catch (Dali::DaliException e) {
57910       {
57911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57912       };
57913     } catch (...) {
57914       {
57915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57916       };
57917     }
57918   }
57919
57920
57921   //argout typemap for const std::string&
57922
57923 }
57924
57925
57926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57927   void * jresult ;
57928   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57929   Dali::Property::Map *result = 0 ;
57930
57931   arg1 = (Dali::Toolkit::Builder *)jarg1;
57932   {
57933     try {
57934       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
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 (Dali::DaliException e) {
57944       {
57945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57946       };
57947     } catch (...) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57950       };
57951     }
57952   }
57953
57954   jresult = (void *)result;
57955   return jresult;
57956 }
57957
57958
57959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57960   void * jresult ;
57961   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57962   std::string *arg2 = 0 ;
57963   Dali::Property::Value *result = 0 ;
57964
57965   arg1 = (Dali::Toolkit::Builder *)jarg1;
57966   if (!jarg2) {
57967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57968     return 0;
57969   }
57970   std::string arg2_str(jarg2);
57971   arg2 = &arg2_str;
57972   {
57973     try {
57974       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57975     } catch (std::out_of_range& e) {
57976       {
57977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57978       };
57979     } catch (std::exception& e) {
57980       {
57981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57982       };
57983     } catch (Dali::DaliException e) {
57984       {
57985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57986       };
57987     } catch (...) {
57988       {
57989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57990       };
57991     }
57992   }
57993
57994   jresult = (void *)result;
57995
57996   //argout typemap for const std::string&
57997
57998   return jresult;
57999 }
58000
58001
58002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58003   void * jresult ;
58004   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58005   std::string *arg2 = 0 ;
58006   Dali::Animation result;
58007
58008   arg1 = (Dali::Toolkit::Builder *)jarg1;
58009   if (!jarg2) {
58010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58011     return 0;
58012   }
58013   std::string arg2_str(jarg2);
58014   arg2 = &arg2_str;
58015   {
58016     try {
58017       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58018     } catch (std::out_of_range& e) {
58019       {
58020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (std::exception& e) {
58023       {
58024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58025       };
58026     } catch (Dali::DaliException e) {
58027       {
58028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58029       };
58030     } catch (...) {
58031       {
58032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58033       };
58034     }
58035   }
58036
58037   jresult = new Dali::Animation((const Dali::Animation &)result);
58038
58039   //argout typemap for const std::string&
58040
58041   return jresult;
58042 }
58043
58044
58045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58046   void * jresult ;
58047   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58048   std::string *arg2 = 0 ;
58049   Dali::Property::Map *arg3 = 0 ;
58050   Dali::Animation result;
58051
58052   arg1 = (Dali::Toolkit::Builder *)jarg1;
58053   if (!jarg2) {
58054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58055     return 0;
58056   }
58057   std::string arg2_str(jarg2);
58058   arg2 = &arg2_str;
58059   arg3 = (Dali::Property::Map *)jarg3;
58060   if (!arg3) {
58061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58062     return 0;
58063   }
58064   {
58065     try {
58066       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58067     } catch (std::out_of_range& e) {
58068       {
58069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58070       };
58071     } catch (std::exception& e) {
58072       {
58073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58074       };
58075     } catch (Dali::DaliException e) {
58076       {
58077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58078       };
58079     } catch (...) {
58080       {
58081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58082       };
58083     }
58084   }
58085
58086   jresult = new Dali::Animation((const Dali::Animation &)result);
58087
58088   //argout typemap for const std::string&
58089
58090   return jresult;
58091 }
58092
58093
58094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58095   void * jresult ;
58096   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58097   std::string *arg2 = 0 ;
58098   Dali::Actor arg3 ;
58099   Dali::Actor *argp3 ;
58100   Dali::Animation result;
58101
58102   arg1 = (Dali::Toolkit::Builder *)jarg1;
58103   if (!jarg2) {
58104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58105     return 0;
58106   }
58107   std::string arg2_str(jarg2);
58108   arg2 = &arg2_str;
58109   argp3 = (Dali::Actor *)jarg3;
58110   if (!argp3) {
58111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58112     return 0;
58113   }
58114   arg3 = *argp3;
58115   {
58116     try {
58117       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58118     } catch (std::out_of_range& e) {
58119       {
58120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58121       };
58122     } catch (std::exception& e) {
58123       {
58124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (Dali::DaliException e) {
58127       {
58128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58129       };
58130     } catch (...) {
58131       {
58132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58133       };
58134     }
58135   }
58136
58137   jresult = new Dali::Animation((const Dali::Animation &)result);
58138
58139   //argout typemap for const std::string&
58140
58141   return jresult;
58142 }
58143
58144
58145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58146   void * jresult ;
58147   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58148   std::string *arg2 = 0 ;
58149   Dali::Property::Map *arg3 = 0 ;
58150   Dali::Actor arg4 ;
58151   Dali::Actor *argp4 ;
58152   Dali::Animation result;
58153
58154   arg1 = (Dali::Toolkit::Builder *)jarg1;
58155   if (!jarg2) {
58156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58157     return 0;
58158   }
58159   std::string arg2_str(jarg2);
58160   arg2 = &arg2_str;
58161   arg3 = (Dali::Property::Map *)jarg3;
58162   if (!arg3) {
58163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58164     return 0;
58165   }
58166   argp4 = (Dali::Actor *)jarg4;
58167   if (!argp4) {
58168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58169     return 0;
58170   }
58171   arg4 = *argp4;
58172   {
58173     try {
58174       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58175     } catch (std::out_of_range& e) {
58176       {
58177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58178       };
58179     } catch (std::exception& e) {
58180       {
58181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58182       };
58183     } catch (Dali::DaliException e) {
58184       {
58185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58186       };
58187     } catch (...) {
58188       {
58189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58190       };
58191     }
58192   }
58193
58194   jresult = new Dali::Animation((const Dali::Animation &)result);
58195
58196   //argout typemap for const std::string&
58197
58198   return jresult;
58199 }
58200
58201
58202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58203   void * jresult ;
58204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58205   std::string *arg2 = 0 ;
58206   Dali::BaseHandle result;
58207
58208   arg1 = (Dali::Toolkit::Builder *)jarg1;
58209   if (!jarg2) {
58210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58211     return 0;
58212   }
58213   std::string arg2_str(jarg2);
58214   arg2 = &arg2_str;
58215   {
58216     try {
58217       result = (arg1)->Create((std::string const &)*arg2);
58218     } catch (std::out_of_range& e) {
58219       {
58220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58221       };
58222     } catch (std::exception& e) {
58223       {
58224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (Dali::DaliException e) {
58227       {
58228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236
58237   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58238
58239   //argout typemap for const std::string&
58240
58241   return jresult;
58242 }
58243
58244
58245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58246   void * jresult ;
58247   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58248   std::string *arg2 = 0 ;
58249   Dali::Property::Map *arg3 = 0 ;
58250   Dali::BaseHandle result;
58251
58252   arg1 = (Dali::Toolkit::Builder *)jarg1;
58253   if (!jarg2) {
58254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58255     return 0;
58256   }
58257   std::string arg2_str(jarg2);
58258   arg2 = &arg2_str;
58259   arg3 = (Dali::Property::Map *)jarg3;
58260   if (!arg3) {
58261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58262     return 0;
58263   }
58264   {
58265     try {
58266       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58267     } catch (std::out_of_range& e) {
58268       {
58269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58270       };
58271     } catch (std::exception& e) {
58272       {
58273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58274       };
58275     } catch (Dali::DaliException e) {
58276       {
58277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58282       };
58283     }
58284   }
58285
58286   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58287
58288   //argout typemap for const std::string&
58289
58290   return jresult;
58291 }
58292
58293
58294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58295   void * jresult ;
58296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58297   std::string *arg2 = 0 ;
58298   Dali::BaseHandle result;
58299
58300   arg1 = (Dali::Toolkit::Builder *)jarg1;
58301   if (!jarg2) {
58302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58303     return 0;
58304   }
58305   std::string arg2_str(jarg2);
58306   arg2 = &arg2_str;
58307   {
58308     try {
58309       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58310     } catch (std::out_of_range& e) {
58311       {
58312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58313       };
58314     } catch (std::exception& e) {
58315       {
58316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58317       };
58318     } catch (Dali::DaliException e) {
58319       {
58320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58321       };
58322     } catch (...) {
58323       {
58324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58325       };
58326     }
58327   }
58328
58329   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58330
58331   //argout typemap for const std::string&
58332
58333   return jresult;
58334 }
58335
58336
58337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58338   unsigned int jresult ;
58339   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58340   std::string *arg2 = 0 ;
58341   Dali::Handle *arg3 = 0 ;
58342   bool result;
58343
58344   arg1 = (Dali::Toolkit::Builder *)jarg1;
58345   if (!jarg2) {
58346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58347     return 0;
58348   }
58349   std::string arg2_str(jarg2);
58350   arg2 = &arg2_str;
58351   arg3 = (Dali::Handle *)jarg3;
58352   if (!arg3) {
58353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58354     return 0;
58355   }
58356   {
58357     try {
58358       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58359     } catch (std::out_of_range& e) {
58360       {
58361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58362       };
58363     } catch (std::exception& e) {
58364       {
58365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58366       };
58367     } catch (Dali::DaliException e) {
58368       {
58369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58370       };
58371     } catch (...) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58374       };
58375     }
58376   }
58377
58378   jresult = result;
58379
58380   //argout typemap for const std::string&
58381
58382   return jresult;
58383 }
58384
58385
58386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58387   unsigned int jresult ;
58388   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58389   Dali::Handle *arg2 = 0 ;
58390   std::string *arg3 = 0 ;
58391   bool result;
58392
58393   arg1 = (Dali::Toolkit::Builder *)jarg1;
58394   arg2 = (Dali::Handle *)jarg2;
58395   if (!arg2) {
58396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58397     return 0;
58398   }
58399   if (!jarg3) {
58400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58401     return 0;
58402   }
58403   std::string arg3_str(jarg3);
58404   arg3 = &arg3_str;
58405   {
58406     try {
58407       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58408     } catch (std::out_of_range& e) {
58409       {
58410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (std::exception& e) {
58413       {
58414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58415       };
58416     } catch (Dali::DaliException e) {
58417       {
58418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58419       };
58420     } catch (...) {
58421       {
58422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58423       };
58424     }
58425   }
58426
58427   jresult = result;
58428
58429   //argout typemap for const std::string&
58430
58431   return jresult;
58432 }
58433
58434
58435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58436   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58437   Dali::Actor arg2 ;
58438   Dali::Actor *argp2 ;
58439
58440   arg1 = (Dali::Toolkit::Builder *)jarg1;
58441   argp2 = (Dali::Actor *)jarg2;
58442   if (!argp2) {
58443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58444     return ;
58445   }
58446   arg2 = *argp2;
58447   {
58448     try {
58449       (arg1)->AddActors(arg2);
58450     } catch (std::out_of_range& e) {
58451       {
58452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58453       };
58454     } catch (std::exception& e) {
58455       {
58456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58457       };
58458     } catch (Dali::DaliException e) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58461       };
58462     } catch (...) {
58463       {
58464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58465       };
58466     }
58467   }
58468
58469 }
58470
58471
58472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58473   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58474   std::string *arg2 = 0 ;
58475   Dali::Actor arg3 ;
58476   Dali::Actor *argp3 ;
58477
58478   arg1 = (Dali::Toolkit::Builder *)jarg1;
58479   if (!jarg2) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58481     return ;
58482   }
58483   std::string arg2_str(jarg2);
58484   arg2 = &arg2_str;
58485   argp3 = (Dali::Actor *)jarg3;
58486   if (!argp3) {
58487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58488     return ;
58489   }
58490   arg3 = *argp3;
58491   {
58492     try {
58493       (arg1)->AddActors((std::string const &)*arg2,arg3);
58494     } catch (std::out_of_range& e) {
58495       {
58496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58497       };
58498     } catch (std::exception& e) {
58499       {
58500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58501       };
58502     } catch (Dali::DaliException e) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58505       };
58506     } catch (...) {
58507       {
58508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58509       };
58510     }
58511   }
58512
58513
58514   //argout typemap for const std::string&
58515
58516 }
58517
58518
58519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58520   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58521   std::string *arg2 = 0 ;
58522
58523   arg1 = (Dali::Toolkit::Builder *)jarg1;
58524   if (!jarg2) {
58525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58526     return ;
58527   }
58528   std::string arg2_str(jarg2);
58529   arg2 = &arg2_str;
58530   {
58531     try {
58532       (arg1)->CreateRenderTask((std::string const &)*arg2);
58533     } catch (std::out_of_range& e) {
58534       {
58535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58536       };
58537     } catch (std::exception& e) {
58538       {
58539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58540       };
58541     } catch (Dali::DaliException e) {
58542       {
58543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58544       };
58545     } catch (...) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58548       };
58549     }
58550   }
58551
58552
58553   //argout typemap for const std::string&
58554
58555 }
58556
58557
58558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58559   void * jresult ;
58560   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58561   std::string *arg2 = 0 ;
58562   Dali::Path result;
58563
58564   arg1 = (Dali::Toolkit::Builder *)jarg1;
58565   if (!jarg2) {
58566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58567     return 0;
58568   }
58569   std::string arg2_str(jarg2);
58570   arg2 = &arg2_str;
58571   {
58572     try {
58573       result = (arg1)->GetPath((std::string const &)*arg2);
58574     } catch (std::out_of_range& e) {
58575       {
58576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58577       };
58578     } catch (std::exception& e) {
58579       {
58580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58581       };
58582     } catch (Dali::DaliException e) {
58583       {
58584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58585       };
58586     } catch (...) {
58587       {
58588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58589       };
58590     }
58591   }
58592
58593   jresult = new Dali::Path((const Dali::Path &)result);
58594
58595   //argout typemap for const std::string&
58596
58597   return jresult;
58598 }
58599
58600
58601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58602   void * jresult ;
58603   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58604   std::string *arg2 = 0 ;
58605   Dali::PathConstrainer result;
58606
58607   arg1 = (Dali::Toolkit::Builder *)jarg1;
58608   if (!jarg2) {
58609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58610     return 0;
58611   }
58612   std::string arg2_str(jarg2);
58613   arg2 = &arg2_str;
58614   {
58615     try {
58616       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58617     } catch (std::out_of_range& e) {
58618       {
58619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58620       };
58621     } catch (std::exception& e) {
58622       {
58623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58624       };
58625     } catch (Dali::DaliException e) {
58626       {
58627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58628       };
58629     } catch (...) {
58630       {
58631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58632       };
58633     }
58634   }
58635
58636   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58637
58638   //argout typemap for const std::string&
58639
58640   return jresult;
58641 }
58642
58643
58644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58645   void * jresult ;
58646   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58647   std::string *arg2 = 0 ;
58648   Dali::LinearConstrainer result;
58649
58650   arg1 = (Dali::Toolkit::Builder *)jarg1;
58651   if (!jarg2) {
58652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58653     return 0;
58654   }
58655   std::string arg2_str(jarg2);
58656   arg2 = &arg2_str;
58657   {
58658     try {
58659       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58660     } catch (std::out_of_range& e) {
58661       {
58662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58663       };
58664     } catch (std::exception& e) {
58665       {
58666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58667       };
58668     } catch (Dali::DaliException e) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58671       };
58672     } catch (...) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58675       };
58676     }
58677   }
58678
58679   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58680
58681   //argout typemap for const std::string&
58682
58683   return jresult;
58684 }
58685
58686
58687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58688   void * jresult ;
58689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58690   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58691
58692   arg1 = (Dali::Toolkit::Builder *)jarg1;
58693   {
58694     try {
58695       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58703       };
58704     } catch (Dali::DaliException e) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58707       };
58708     } catch (...) {
58709       {
58710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58711       };
58712     }
58713   }
58714
58715   jresult = (void *)result;
58716   return jresult;
58717 }
58718
58719
58720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58721   void * jresult ;
58722   Dali::Toolkit::TransitionData *result = 0 ;
58723
58724   {
58725     try {
58726       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58727     } catch (std::out_of_range& e) {
58728       {
58729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58730       };
58731     } catch (std::exception& e) {
58732       {
58733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58734       };
58735     } catch (Dali::DaliException e) {
58736       {
58737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58738       };
58739     } catch (...) {
58740       {
58741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58742       };
58743     }
58744   }
58745
58746   jresult = (void *)result;
58747   return jresult;
58748 }
58749
58750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58751   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58752
58753   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58754   {
58755     try {
58756       delete arg1;
58757     } catch (std::out_of_range& e) {
58758       {
58759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58760       };
58761     } catch (std::exception& e) {
58762       {
58763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58764       };
58765     } catch (Dali::DaliException e) {
58766       {
58767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58768       };
58769     } catch (...) {
58770       {
58771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58772       };
58773     }
58774   }
58775
58776 }
58777
58778
58779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58780   void * jresult ;
58781   Dali::Property::Map *arg1 = 0 ;
58782   Dali::Toolkit::TransitionData result;
58783
58784   arg1 = (Dali::Property::Map *)jarg1;
58785   if (!arg1) {
58786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58787     return 0;
58788   }
58789   {
58790     try {
58791       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58792     } catch (std::out_of_range& e) {
58793       {
58794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58795       };
58796     } catch (std::exception& e) {
58797       {
58798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58799       };
58800     } catch (Dali::DaliException e) {
58801       {
58802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58803       };
58804     } catch (...) {
58805       {
58806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58807       };
58808     }
58809   }
58810
58811   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58812   return jresult;
58813 }
58814
58815
58816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58817   void * jresult ;
58818   Dali::Property::Array *arg1 = 0 ;
58819   Dali::Toolkit::TransitionData result;
58820
58821   arg1 = (Dali::Property::Array *)jarg1;
58822   if (!arg1) {
58823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58824     return 0;
58825   }
58826   {
58827     try {
58828       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58829     } catch (std::out_of_range& e) {
58830       {
58831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58832       };
58833     } catch (std::exception& e) {
58834       {
58835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58836       };
58837     } catch (Dali::DaliException e) {
58838       {
58839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58840       };
58841     } catch (...) {
58842       {
58843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58844       };
58845     }
58846   }
58847
58848   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58849   return jresult;
58850 }
58851
58852
58853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58854   void * jresult ;
58855   Dali::BaseHandle arg1 ;
58856   Dali::BaseHandle *argp1 ;
58857   Dali::Toolkit::TransitionData result;
58858
58859   argp1 = (Dali::BaseHandle *)jarg1;
58860   if (!argp1) {
58861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58862     return 0;
58863   }
58864   arg1 = *argp1;
58865   {
58866     try {
58867       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58868     } catch (std::out_of_range& e) {
58869       {
58870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58871       };
58872     } catch (std::exception& e) {
58873       {
58874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58875       };
58876     } catch (Dali::DaliException e) {
58877       {
58878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58879       };
58880     } catch (...) {
58881       {
58882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58883       };
58884     }
58885   }
58886
58887   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58888   return jresult;
58889 }
58890
58891
58892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58893   void * jresult ;
58894   Dali::Toolkit::TransitionData *arg1 = 0 ;
58895   Dali::Toolkit::TransitionData *result = 0 ;
58896
58897   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58898   if (!arg1) {
58899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58900     return 0;
58901   }
58902   {
58903     try {
58904       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58905     } catch (std::out_of_range& e) {
58906       {
58907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58908       };
58909     } catch (std::exception& e) {
58910       {
58911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58912       };
58913     } catch (Dali::DaliException e) {
58914       {
58915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58916       };
58917     } catch (...) {
58918       {
58919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58920       };
58921     }
58922   }
58923
58924   jresult = (void *)result;
58925   return jresult;
58926 }
58927
58928
58929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58930   void * jresult ;
58931   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58932   Dali::Toolkit::TransitionData *arg2 = 0 ;
58933   Dali::Toolkit::TransitionData *result = 0 ;
58934
58935   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58936   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58937   if (!arg2) {
58938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58939     return 0;
58940   }
58941   {
58942     try {
58943       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58944     } catch (std::out_of_range& e) {
58945       {
58946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58947       };
58948     } catch (std::exception& e) {
58949       {
58950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58951       };
58952     } catch (Dali::DaliException e) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58955       };
58956     } catch (...) {
58957       {
58958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58959       };
58960     }
58961   }
58962
58963   jresult = (void *)result;
58964   return jresult;
58965 }
58966
58967
58968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58969   unsigned long jresult ;
58970   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58971   size_t result;
58972
58973   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58974   {
58975     try {
58976       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (Dali::DaliException e) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58988       };
58989     } catch (...) {
58990       {
58991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58992       };
58993     }
58994   }
58995
58996   jresult = (unsigned long)result;
58997   return jresult;
58998 }
58999
59000
59001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59002   void * jresult ;
59003   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59004   size_t arg2 ;
59005   Dali::Property::Map result;
59006
59007   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59008   arg2 = (size_t)jarg2;
59009   {
59010     try {
59011       result = (arg1)->GetAnimatorAt(arg2);
59012     } catch (std::out_of_range& e) {
59013       {
59014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59015       };
59016     } catch (std::exception& e) {
59017       {
59018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59019       };
59020     } catch (Dali::DaliException e) {
59021       {
59022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59023       };
59024     } catch (...) {
59025       {
59026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59027       };
59028     }
59029   }
59030
59031   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59032   return jresult;
59033 }
59034
59035
59036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59037   int jresult ;
59038   int result;
59039
59040   {
59041     try {
59042       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
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 (Dali::DaliException e) {
59052       {
59053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59054       };
59055     } catch (...) {
59056       {
59057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59058       };
59059     }
59060   }
59061
59062   jresult = (int)result;
59063   return jresult;
59064 }
59065
59066
59067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59068   int jresult ;
59069   int result;
59070
59071   {
59072     try {
59073       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59074     } catch (std::out_of_range& e) {
59075       {
59076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59077       };
59078     } catch (std::exception& e) {
59079       {
59080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59081       };
59082     } catch (Dali::DaliException e) {
59083       {
59084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59085       };
59086     } catch (...) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59089       };
59090     }
59091   }
59092
59093   jresult = (int)result;
59094   return jresult;
59095 }
59096
59097
59098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59099   int jresult ;
59100   int result;
59101
59102   {
59103     try {
59104       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59105     } catch (std::out_of_range& e) {
59106       {
59107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59108       };
59109     } catch (std::exception& e) {
59110       {
59111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59112       };
59113     } catch (Dali::DaliException e) {
59114       {
59115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59116       };
59117     } catch (...) {
59118       {
59119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59120       };
59121     }
59122   }
59123
59124   jresult = (int)result;
59125   return jresult;
59126 }
59127
59128
59129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59130   int jresult ;
59131   int result;
59132
59133   {
59134     try {
59135       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59136     } catch (std::out_of_range& e) {
59137       {
59138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59139       };
59140     } catch (std::exception& e) {
59141       {
59142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59143       };
59144     } catch (Dali::DaliException e) {
59145       {
59146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59147       };
59148     } catch (...) {
59149       {
59150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59151       };
59152     }
59153   }
59154
59155   jresult = (int)result;
59156   return jresult;
59157 }
59158
59159
59160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59161   int jresult ;
59162   int result;
59163
59164   {
59165     try {
59166       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59167     } catch (std::out_of_range& e) {
59168       {
59169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59170       };
59171     } catch (std::exception& e) {
59172       {
59173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59174       };
59175     } catch (Dali::DaliException e) {
59176       {
59177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59178       };
59179     } catch (...) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59182       };
59183     }
59184   }
59185
59186   jresult = (int)result;
59187   return jresult;
59188 }
59189
59190
59191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59192   int jresult ;
59193   int result;
59194
59195   {
59196     try {
59197       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59198     } catch (std::out_of_range& e) {
59199       {
59200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59201       };
59202     } catch (std::exception& e) {
59203       {
59204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59205       };
59206     } catch (Dali::DaliException e) {
59207       {
59208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59209       };
59210     } catch (...) {
59211       {
59212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59213       };
59214     }
59215   }
59216
59217   jresult = (int)result;
59218   return jresult;
59219 }
59220
59221
59222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59223   int jresult ;
59224   int result;
59225
59226   {
59227     try {
59228       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (Dali::DaliException e) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59240       };
59241     } catch (...) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59244       };
59245     }
59246   }
59247
59248   jresult = (int)result;
59249   return jresult;
59250 }
59251
59252
59253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59254   int jresult ;
59255   int result;
59256
59257   {
59258     try {
59259       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59260     } catch (std::out_of_range& e) {
59261       {
59262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59263       };
59264     } catch (std::exception& e) {
59265       {
59266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59267       };
59268     } catch (Dali::DaliException e) {
59269       {
59270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59271       };
59272     } catch (...) {
59273       {
59274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59275       };
59276     }
59277   }
59278
59279   jresult = (int)result;
59280   return jresult;
59281 }
59282
59283
59284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59285   int jresult ;
59286   int result;
59287
59288   {
59289     try {
59290       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59291     } catch (std::out_of_range& e) {
59292       {
59293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59294       };
59295     } catch (std::exception& e) {
59296       {
59297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59298       };
59299     } catch (Dali::DaliException e) {
59300       {
59301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59302       };
59303     } catch (...) {
59304       {
59305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59306       };
59307     }
59308   }
59309
59310   jresult = (int)result;
59311   return jresult;
59312 }
59313
59314
59315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59316   int jresult ;
59317   int result;
59318
59319   {
59320     try {
59321       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59322     } catch (std::out_of_range& e) {
59323       {
59324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59325       };
59326     } catch (std::exception& e) {
59327       {
59328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59329       };
59330     } catch (Dali::DaliException e) {
59331       {
59332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59333       };
59334     } catch (...) {
59335       {
59336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59337       };
59338     }
59339   }
59340
59341   jresult = (int)result;
59342   return jresult;
59343 }
59344
59345
59346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59347   int jresult ;
59348   int result;
59349
59350   {
59351     try {
59352       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59353     } catch (std::out_of_range& e) {
59354       {
59355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59356       };
59357     } catch (std::exception& e) {
59358       {
59359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59360       };
59361     } catch (Dali::DaliException e) {
59362       {
59363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59364       };
59365     } catch (...) {
59366       {
59367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59368       };
59369     }
59370   }
59371
59372   jresult = (int)result;
59373   return jresult;
59374 }
59375
59376
59377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59378   int jresult ;
59379   int result;
59380
59381   {
59382     try {
59383       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59384     } catch (std::out_of_range& e) {
59385       {
59386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59387       };
59388     } catch (std::exception& e) {
59389       {
59390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59391       };
59392     } catch (Dali::DaliException e) {
59393       {
59394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59399       };
59400     }
59401   }
59402
59403   jresult = (int)result;
59404   return jresult;
59405 }
59406
59407
59408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59409   int jresult ;
59410   int result;
59411
59412   {
59413     try {
59414       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59415     } catch (std::out_of_range& e) {
59416       {
59417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59418       };
59419     } catch (std::exception& e) {
59420       {
59421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59422       };
59423     } catch (Dali::DaliException e) {
59424       {
59425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59426       };
59427     } catch (...) {
59428       {
59429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59430       };
59431     }
59432   }
59433
59434   jresult = (int)result;
59435   return jresult;
59436 }
59437
59438
59439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59440   int jresult ;
59441   int result;
59442
59443   {
59444     try {
59445       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59446     } catch (std::out_of_range& e) {
59447       {
59448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59449       };
59450     } catch (std::exception& e) {
59451       {
59452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (Dali::DaliException e) {
59455       {
59456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464
59465   jresult = (int)result;
59466   return jresult;
59467 }
59468
59469
59470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59471   void * jresult ;
59472   Dali::Toolkit::Control result;
59473
59474   {
59475     try {
59476       result = Dali::Toolkit::Internal::Control::New();
59477     } catch (std::out_of_range& e) {
59478       {
59479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59480       };
59481     } catch (std::exception& e) {
59482       {
59483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (Dali::DaliException e) {
59486       {
59487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59492       };
59493     }
59494   }
59495
59496   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59497   return jresult;
59498 }
59499
59500
59501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59503   std::string *arg2 = 0 ;
59504
59505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59506   if (!jarg2) {
59507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59508     return ;
59509   }
59510   std::string arg2_str(jarg2);
59511   arg2 = &arg2_str;
59512   {
59513     try {
59514       (arg1)->SetStyleName((std::string const &)*arg2);
59515     } catch (std::out_of_range& e) {
59516       {
59517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59518       };
59519     } catch (std::exception& e) {
59520       {
59521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59522       };
59523     } catch (Dali::DaliException e) {
59524       {
59525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59526       };
59527     } catch (...) {
59528       {
59529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59530       };
59531     }
59532   }
59533
59534
59535   //argout typemap for const std::string&
59536
59537 }
59538
59539
59540 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59541   char * jresult ;
59542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59543   std::string *result = 0 ;
59544
59545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59546   {
59547     try {
59548       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59549     } catch (std::out_of_range& e) {
59550       {
59551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59552       };
59553     } catch (std::exception& e) {
59554       {
59555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59556       };
59557     } catch (Dali::DaliException e) {
59558       {
59559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59560       };
59561     } catch (...) {
59562       {
59563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59564       };
59565     }
59566   }
59567
59568   jresult = SWIG_csharp_string_callback(result->c_str());
59569   return jresult;
59570 }
59571
59572
59573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59575   Dali::Vector4 *arg2 = 0 ;
59576
59577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59578   arg2 = (Dali::Vector4 *)jarg2;
59579   if (!arg2) {
59580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59581     return ;
59582   }
59583   {
59584     try {
59585       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59593       };
59594     } catch (Dali::DaliException e) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59597       };
59598     } catch (...) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59601       };
59602     }
59603   }
59604
59605 }
59606
59607
59608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59609   void * jresult ;
59610   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59611   Dali::Vector4 result;
59612
59613   arg1 = (Dali::Handle *)jarg1;
59614   {
59615     try {
59616       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59617       if (resultMap)
59618       {
59619         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59620         if(type && type->Get<int>() == Visual::COLOR )
59621         {
59622           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59623           if (value)
59624           {
59625             result = value->Get<Vector4>();
59626           }
59627         }
59628       }
59629     } catch (std::out_of_range& e) {
59630       {
59631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59632       };
59633     } catch (std::exception& e) {
59634       {
59635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59636       };
59637     } catch (Dali::DaliException e) {
59638       {
59639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59640       };
59641     } catch (...) {
59642       {
59643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59644       };
59645     }
59646   }
59647
59648   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59649   return jresult;
59650 }
59651
59652
59653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59655   Dali::Property::Map *arg2 = 0 ;
59656
59657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59658   arg2 = (Dali::Property::Map *)jarg2;
59659   if (!arg2) {
59660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59661     return ;
59662   }
59663   {
59664     try {
59665       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59666     } catch (std::out_of_range& e) {
59667       {
59668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59669       };
59670     } catch (std::exception& e) {
59671       {
59672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59673       };
59674     } catch (Dali::DaliException e) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59677       };
59678     } catch (...) {
59679       {
59680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59681       };
59682     }
59683   }
59684
59685 }
59686
59687
59688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59690
59691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59692   {
59693     try {
59694       (arg1)->ClearBackground();
59695     } catch (std::out_of_range& e) {
59696       {
59697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59698       };
59699     } catch (std::exception& e) {
59700       {
59701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59702       };
59703     } catch (Dali::DaliException e) {
59704       {
59705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59706       };
59707     } catch (...) {
59708       {
59709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59710       };
59711     }
59712   }
59713
59714 }
59715
59716
59717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59719   Dali::Gesture::Type arg2 ;
59720
59721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59722   arg2 = (Dali::Gesture::Type)jarg2;
59723   {
59724     try {
59725       (arg1)->EnableGestureDetection(arg2);
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59733       };
59734     } catch (Dali::DaliException e) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59737       };
59738     } catch (...) {
59739       {
59740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59741       };
59742     }
59743   }
59744
59745 }
59746
59747
59748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59750   Dali::Gesture::Type arg2 ;
59751
59752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59753   arg2 = (Dali::Gesture::Type)jarg2;
59754   {
59755     try {
59756       (arg1)->DisableGestureDetection(arg2);
59757     } catch (std::out_of_range& e) {
59758       {
59759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59760       };
59761     } catch (std::exception& e) {
59762       {
59763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59764       };
59765     } catch (Dali::DaliException e) {
59766       {
59767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59768       };
59769     } catch (...) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59772       };
59773     }
59774   }
59775
59776 }
59777
59778
59779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59780   void * jresult ;
59781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59782   Dali::PinchGestureDetector result;
59783
59784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59785   {
59786     try {
59787       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59788     } catch (std::out_of_range& e) {
59789       {
59790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (std::exception& e) {
59793       {
59794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (Dali::DaliException e) {
59797       {
59798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59803       };
59804     }
59805   }
59806
59807   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59808   return jresult;
59809 }
59810
59811
59812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59813   void * jresult ;
59814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59815   Dali::PanGestureDetector result;
59816
59817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59818   {
59819     try {
59820       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59821     } catch (std::out_of_range& e) {
59822       {
59823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (std::exception& e) {
59826       {
59827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (Dali::DaliException e) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59832       };
59833     } catch (...) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59836       };
59837     }
59838   }
59839
59840   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59841   return jresult;
59842 }
59843
59844
59845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59846   void * jresult ;
59847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59848   Dali::TapGestureDetector result;
59849
59850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59851   {
59852     try {
59853       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59854     } catch (std::out_of_range& e) {
59855       {
59856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59857       };
59858     } catch (std::exception& e) {
59859       {
59860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59861       };
59862     } catch (Dali::DaliException e) {
59863       {
59864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59865       };
59866     } catch (...) {
59867       {
59868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59869       };
59870     }
59871   }
59872
59873   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59874   return jresult;
59875 }
59876
59877
59878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59879   void * jresult ;
59880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59881   Dali::LongPressGestureDetector result;
59882
59883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59884   {
59885     try {
59886       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59887     } catch (std::out_of_range& e) {
59888       {
59889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59890       };
59891     } catch (std::exception& e) {
59892       {
59893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59894       };
59895     } catch (Dali::DaliException e) {
59896       {
59897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59898       };
59899     } catch (...) {
59900       {
59901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59902       };
59903     }
59904   }
59905
59906   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59907   return jresult;
59908 }
59909
59910
59911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59913   bool arg2 ;
59914
59915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59916   arg2 = jarg2 ? true : false;
59917   {
59918     try {
59919       (arg1)->SetKeyboardNavigationSupport(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 (Dali::DaliException e) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59931       };
59932     } catch (...) {
59933       {
59934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59935       };
59936     }
59937   }
59938
59939 }
59940
59941
59942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59943   unsigned int jresult ;
59944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59945   bool result;
59946
59947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59948   {
59949     try {
59950       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59951     } catch (std::out_of_range& e) {
59952       {
59953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59954       };
59955     } catch (std::exception& e) {
59956       {
59957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59958       };
59959     } catch (Dali::DaliException e) {
59960       {
59961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59962       };
59963     } catch (...) {
59964       {
59965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59966       };
59967     }
59968   }
59969
59970   jresult = result;
59971   return jresult;
59972 }
59973
59974
59975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59977
59978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59979   {
59980     try {
59981       (arg1)->SetKeyInputFocus();
59982     } catch (std::out_of_range& e) {
59983       {
59984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59985       };
59986     } catch (std::exception& e) {
59987       {
59988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59989       };
59990     } catch (Dali::DaliException e) {
59991       {
59992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59993       };
59994     } catch (...) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59997       };
59998     }
59999   }
60000
60001 }
60002
60003
60004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60005   unsigned int jresult ;
60006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60007   bool result;
60008
60009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60010   {
60011     try {
60012       result = (bool)(arg1)->HasKeyInputFocus();
60013     } catch (std::out_of_range& e) {
60014       {
60015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60016       };
60017     } catch (std::exception& e) {
60018       {
60019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60020       };
60021     } catch (Dali::DaliException e) {
60022       {
60023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60024       };
60025     } catch (...) {
60026       {
60027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60028       };
60029     }
60030   }
60031
60032   jresult = result;
60033   return jresult;
60034 }
60035
60036
60037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60039
60040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60041   {
60042     try {
60043       (arg1)->ClearKeyInputFocus();
60044     } catch (std::out_of_range& e) {
60045       {
60046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60047       };
60048     } catch (std::exception& e) {
60049       {
60050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60051       };
60052     } catch (Dali::DaliException e) {
60053       {
60054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60055       };
60056     } catch (...) {
60057       {
60058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60059       };
60060     }
60061   }
60062
60063 }
60064
60065
60066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60068   bool arg2 ;
60069
60070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60071   arg2 = jarg2 ? true : false;
60072   {
60073     try {
60074       (arg1)->SetAsKeyboardFocusGroup(arg2);
60075     } catch (std::out_of_range& e) {
60076       {
60077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60078       };
60079     } catch (std::exception& e) {
60080       {
60081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60082       };
60083     } catch (Dali::DaliException e) {
60084       {
60085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60086       };
60087     } catch (...) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60090       };
60091     }
60092   }
60093
60094 }
60095
60096
60097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60098   unsigned int jresult ;
60099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60100   bool result;
60101
60102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60103   {
60104     try {
60105       result = (bool)(arg1)->IsKeyboardFocusGroup();
60106     } catch (std::out_of_range& e) {
60107       {
60108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60109       };
60110     } catch (std::exception& e) {
60111       {
60112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60113       };
60114     } catch (Dali::DaliException e) {
60115       {
60116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60117       };
60118     } catch (...) {
60119       {
60120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60121       };
60122     }
60123   }
60124
60125   jresult = result;
60126   return jresult;
60127 }
60128
60129
60130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60131   void * jresult ;
60132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60133   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60134
60135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60136   {
60137     try {
60138       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60139     } catch (std::out_of_range& e) {
60140       {
60141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (std::exception& e) {
60144       {
60145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (Dali::DaliException e) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60150       };
60151     } catch (...) {
60152       {
60153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60154       };
60155     }
60156   }
60157
60158   jresult = (void *)result;
60159   return jresult;
60160 }
60161
60162
60163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60164   void * jresult ;
60165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60166   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60167
60168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60169   {
60170     try {
60171       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (Dali::DaliException e) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190
60191   jresult = (void *)result;
60192   return jresult;
60193 }
60194
60195
60196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60197   void * jresult ;
60198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60199   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60200
60201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60202   {
60203     try {
60204       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60205     } catch (std::out_of_range& e) {
60206       {
60207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60208       };
60209     } catch (std::exception& e) {
60210       {
60211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60212       };
60213     } catch (Dali::DaliException e) {
60214       {
60215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60216       };
60217     } catch (...) {
60218       {
60219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60220       };
60221     }
60222   }
60223
60224   jresult = (void *)result;
60225   return jresult;
60226 }
60227
60228
60229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
60230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60231   int arg2 ;
60232   SwigDirector_ViewImpl *darg = 0;
60233
60234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60235   arg2 = (int)jarg2;
60236   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60237   if(!darg) {
60238     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60239     return;
60240   }
60241   {
60242     try {
60243       if(darg) {
60244         (darg)->OnSceneConnection(arg2);
60245       }
60246     } catch (std::out_of_range& e) {
60247       {
60248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60249       };
60250     } catch (std::exception& e) {
60251       {
60252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60253       };
60254     } catch (Dali::DaliException e) {
60255       {
60256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60257       };
60258     } catch (...) {
60259       {
60260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60261       };
60262     }
60263   }
60264
60265 }
60266
60267
60268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60270   int arg2 ;
60271   SwigDirector_ViewImpl *darg = 0;
60272
60273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60274   arg2 = (int)jarg2;
60275   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60276   if(!darg) {
60277     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60278     return;
60279   }
60280   {
60281     try {
60282       if(darg) {
60283         (darg)->OnSceneConnectionSwigPublic(arg2);
60284       }
60285     } catch (std::out_of_range& e) {
60286       {
60287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60288       };
60289     } catch (std::exception& e) {
60290       {
60291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60292       };
60293     } catch (Dali::DaliException e) {
60294       {
60295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60296       };
60297     } catch (...) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60300       };
60301     }
60302   }
60303
60304 }
60305
60306
60307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
60308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60309   SwigDirector_ViewImpl *darg = 0;
60310
60311   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60313   if(!darg) {
60314     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60315     return;
60316   }
60317   {
60318     try {
60319       if(darg) {
60320         (darg)->OnSceneDisconnection();
60321       }
60322     } catch (std::out_of_range& e) {
60323       {
60324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60325       };
60326     } catch (std::exception& e) {
60327       {
60328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60329       };
60330     } catch (Dali::DaliException e) {
60331       {
60332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60333       };
60334     } catch (...) {
60335       {
60336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60337       };
60338     }
60339   }
60340
60341 }
60342
60343
60344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60346   SwigDirector_ViewImpl *darg = 0;
60347
60348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60349   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60350   if(!darg) {
60351     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60352     return;
60353   }
60354   {
60355     try {
60356       if(darg) {
60357         (darg)->OnSceneDisconnectionSwigPublic();
60358       }
60359     } catch (std::out_of_range& e) {
60360       {
60361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60362       };
60363     } catch (std::exception& e) {
60364       {
60365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60366       };
60367     } catch (Dali::DaliException e) {
60368       {
60369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60374       };
60375     }
60376   }
60377
60378 }
60379
60380
60381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60383   Dali::Actor *arg2 = 0 ;
60384   SwigDirector_ViewImpl *darg = 0;
60385
60386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60387   arg2 = (Dali::Actor *)jarg2;
60388   if (!arg2) {
60389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60390     return ;
60391   }
60392   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60393   if(!darg) {
60394     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60395     return;
60396   }
60397   {
60398     try {
60399       if(darg) {
60400         (darg)->OnChildAdd(*arg2);
60401       }
60402     } catch (std::out_of_range& e) {
60403       {
60404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60405       };
60406     } catch (std::exception& e) {
60407       {
60408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60409       };
60410     } catch (Dali::DaliException e) {
60411       {
60412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60413       };
60414     } catch (...) {
60415       {
60416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60417       };
60418     }
60419   }
60420
60421 }
60422
60423
60424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60425   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60426   Dali::Actor *arg2 = 0 ;
60427   SwigDirector_ViewImpl *darg = 0;
60428
60429   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60430   arg2 = (Dali::Actor *)jarg2;
60431   if (!arg2) {
60432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60433     return ;
60434   }
60435   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60436   if(!darg) {
60437     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60438     return;
60439   }
60440   {
60441     try {
60442       if(darg) {
60443           (darg)->OnChildAddSwigPublic(*arg2);
60444       }
60445     } catch (std::out_of_range& e) {
60446       {
60447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60448       };
60449     } catch (std::exception& e) {
60450       {
60451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60452       };
60453     } catch (Dali::DaliException e) {
60454       {
60455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60456       };
60457     } catch (...) {
60458       {
60459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60460       };
60461     }
60462   }
60463
60464 }
60465
60466
60467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60469   Dali::Actor *arg2 = 0 ;
60470   SwigDirector_ViewImpl *darg = 0;
60471
60472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60473   arg2 = (Dali::Actor *)jarg2;
60474   if (!arg2) {
60475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60476     return ;
60477   }
60478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60479   if(!darg) {
60480     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60481     return;
60482   }
60483   {
60484     try {
60485       if(darg) {
60486         (darg)->OnChildRemove(*arg2);
60487       }
60488     } catch (std::out_of_range& e) {
60489       {
60490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60491       };
60492     } catch (std::exception& e) {
60493       {
60494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60495       };
60496     } catch (Dali::DaliException e) {
60497       {
60498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60499       };
60500     } catch (...) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60503       };
60504     }
60505   }
60506
60507 }
60508
60509
60510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60512   Dali::Actor *arg2 = 0 ;
60513   SwigDirector_ViewImpl *darg = 0;
60514
60515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60516   arg2 = (Dali::Actor *)jarg2;
60517   if (!arg2) {
60518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60519     return ;
60520   }
60521   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60522   if(!darg) {
60523     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60524     return;
60525   }
60526   {
60527     try {
60528       if(darg) {
60529         (darg)->OnChildRemoveSwigPublic(*arg2);
60530       }
60531     } catch (std::out_of_range& e) {
60532       {
60533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60534       };
60535     } catch (std::exception& e) {
60536       {
60537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60538       };
60539     } catch (Dali::DaliException e) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60542       };
60543     } catch (...) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60546       };
60547     }
60548   }
60549
60550 }
60551
60552
60553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60555   Dali::Property::Index arg2 ;
60556   Dali::Property::Value arg3 ;
60557   Dali::Property::Value *argp3 ;
60558   SwigDirector_ViewImpl *darg = 0;
60559
60560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60561   arg2 = (Dali::Property::Index)jarg2;
60562   argp3 = (Dali::Property::Value *)jarg3;
60563   if (!argp3) {
60564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60565     return ;
60566   }
60567   arg3 = *argp3;
60568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60569   if (!darg) {
60570     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60571     return;
60572   }
60573   {
60574     try {
60575       (darg)->OnPropertySet(arg2,arg3);
60576     } catch (std::out_of_range& e) {
60577       {
60578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60579       };
60580     } catch (std::exception& e) {
60581       {
60582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60583       };
60584     } catch (Dali::DaliException e) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60591       };
60592     }
60593   }
60594
60595 }
60596
60597
60598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60600   Dali::Property::Index arg2 ;
60601   Dali::Property::Value arg3 ;
60602   Dali::Property::Value *argp3 ;
60603   SwigDirector_ViewImpl *darg = 0;
60604
60605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60606   arg2 = (Dali::Property::Index)jarg2;
60607   argp3 = (Dali::Property::Value *)jarg3;
60608   if (!argp3) {
60609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60610     return ;
60611   }
60612   arg3 = *argp3;
60613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60614   if (!darg) {
60615     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60616     return;
60617   }
60618   {
60619     try {
60620       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60621     } catch (std::out_of_range& e) {
60622       {
60623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60624       };
60625     } catch (std::exception& e) {
60626       {
60627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60628       };
60629     } catch (Dali::DaliException e) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60632       };
60633     } catch (...) {
60634       {
60635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60636       };
60637     }
60638   }
60639
60640 }
60641
60642
60643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60645   Dali::Vector3 *arg2 = 0 ;
60646   SwigDirector_ViewImpl *darg = 0;
60647
60648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60649   arg2 = (Dali::Vector3 *)jarg2;
60650   if (!arg2) {
60651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60652     return ;
60653   }
60654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60655   if (!darg) {
60656     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60657     return;
60658   }
60659   {
60660     try {
60661       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60662     } catch (std::out_of_range& e) {
60663       {
60664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60665       };
60666     } catch (std::exception& e) {
60667       {
60668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60669       };
60670     } catch (Dali::DaliException e) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60673       };
60674     } catch (...) {
60675       {
60676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60677       };
60678     }
60679   }
60680
60681 }
60682
60683
60684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60686   Dali::Vector3 *arg2 = 0 ;
60687   SwigDirector_ViewImpl *darg = 0;
60688
60689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60690   arg2 = (Dali::Vector3 *)jarg2;
60691   if (!arg2) {
60692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60693     return ;
60694   }
60695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60696   if (!darg) {
60697     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60698     return;
60699   }
60700   {
60701     try {
60702       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60703     } catch (std::out_of_range& e) {
60704       {
60705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60706       };
60707     } catch (std::exception& e) {
60708       {
60709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60710       };
60711     } catch (Dali::DaliException e) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60714       };
60715     } catch (...) {
60716       {
60717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60718       };
60719     }
60720   }
60721
60722 }
60723
60724
60725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60727   Dali::Animation *arg2 = 0 ;
60728   Dali::Vector3 *arg3 = 0 ;
60729   SwigDirector_ViewImpl *darg = 0;
60730
60731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60732   arg2 = (Dali::Animation *)jarg2;
60733   if (!arg2) {
60734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60735     return ;
60736   }
60737   arg3 = (Dali::Vector3 *)jarg3;
60738   if (!arg3) {
60739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60740     return ;
60741   }
60742   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60743   if (!darg) {
60744     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60745     return;
60746   }
60747   {
60748     try {
60749       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60750     } catch (std::out_of_range& e) {
60751       {
60752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60753       };
60754     } catch (std::exception& e) {
60755       {
60756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60757       };
60758     } catch (Dali::DaliException e) {
60759       {
60760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60761       };
60762     } catch (...) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60765       };
60766     }
60767   }
60768
60769 }
60770
60771
60772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60774   Dali::Animation *arg2 = 0 ;
60775   Dali::Vector3 *arg3 = 0 ;
60776   SwigDirector_ViewImpl *darg = 0;
60777
60778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60779   arg2 = (Dali::Animation *)jarg2;
60780   if (!arg2) {
60781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60782     return ;
60783   }
60784   arg3 = (Dali::Vector3 *)jarg3;
60785   if (!arg3) {
60786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60787     return ;
60788   }
60789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60790   if (!darg) {
60791     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60792     return;
60793   }
60794   {
60795     try {
60796       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60797     } catch (std::out_of_range& e) {
60798       {
60799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60800       };
60801     } catch (std::exception& e) {
60802       {
60803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60804       };
60805     } catch (Dali::DaliException e) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60808       };
60809     } catch (...) {
60810       {
60811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60812       };
60813     }
60814   }
60815 }
60816
60817
60818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60819   unsigned int jresult ;
60820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60821   Dali::HoverEvent *arg2 = 0 ;
60822   SwigDirector_ViewImpl *darg = 0;
60823   bool result;
60824
60825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60826   arg2 = (Dali::HoverEvent *)jarg2;
60827   if (!arg2) {
60828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60829     return 0;
60830   }
60831   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60832   if (!darg) {
60833     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60834     return 0;
60835   }
60836   {
60837     try {
60838       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60839     } catch (std::out_of_range& e) {
60840       {
60841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60842       };
60843     } catch (std::exception& e) {
60844       {
60845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60846       };
60847     } catch (Dali::DaliException e) {
60848       {
60849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60850       };
60851     } catch (...) {
60852       {
60853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60854       };
60855     }
60856   }
60857
60858   jresult = result;
60859   return jresult;
60860 }
60861
60862
60863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60864   unsigned int jresult ;
60865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60866   Dali::HoverEvent *arg2 = 0 ;
60867   SwigDirector_ViewImpl *darg = 0;
60868   bool result;
60869
60870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60871   arg2 = (Dali::HoverEvent *)jarg2;
60872   if (!arg2) {
60873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60874     return 0;
60875   }
60876   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60877   if (!darg) {
60878     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60879     return 0;
60880   }
60881   {
60882     try {
60883       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60884     } catch (std::out_of_range& e) {
60885       {
60886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60887       };
60888     } catch (std::exception& e) {
60889       {
60890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (Dali::DaliException e) {
60893       {
60894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902
60903   jresult = result;
60904   return jresult;
60905 }
60906
60907
60908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60909   unsigned int jresult ;
60910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60911   Dali::KeyEvent *arg2 = 0 ;
60912   SwigDirector_ViewImpl *darg = 0;
60913   bool result;
60914
60915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60916   arg2 = (Dali::KeyEvent *)jarg2;
60917   if (!arg2) {
60918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60919     return 0;
60920   }
60921   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60922   if (!darg) {
60923     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60924     return 0;
60925   }
60926   {
60927     try {
60928       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60929     } catch (std::out_of_range& e) {
60930       {
60931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60932       };
60933     } catch (std::exception& e) {
60934       {
60935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60936       };
60937     } catch (Dali::DaliException e) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60940       };
60941     } catch (...) {
60942       {
60943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60944       };
60945     }
60946   }
60947
60948   jresult = result;
60949   return jresult;
60950 }
60951
60952
60953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60954   unsigned int jresult ;
60955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60956   Dali::KeyEvent *arg2 = 0 ;
60957   SwigDirector_ViewImpl *darg = 0;
60958   bool result;
60959
60960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60961   arg2 = (Dali::KeyEvent *)jarg2;
60962   if (!arg2) {
60963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60964     return 0;
60965   }
60966   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60967   if (!darg) {
60968     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60969     return 0;
60970   }
60971   {
60972     try {
60973       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60974     } catch (std::out_of_range& e) {
60975       {
60976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60977       };
60978     } catch (std::exception& e) {
60979       {
60980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (Dali::DaliException e) {
60983       {
60984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60985       };
60986     } catch (...) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60989       };
60990     }
60991   }
60992
60993   jresult = result;
60994   return jresult;
60995 }
60996
60997
60998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60999   unsigned int jresult ;
61000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61001   Dali::WheelEvent *arg2 = 0 ;
61002   SwigDirector_ViewImpl *darg = 0;
61003   bool result;
61004
61005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61006   arg2 = (Dali::WheelEvent *)jarg2;
61007   if (!arg2) {
61008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61009     return 0;
61010   }
61011   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61012   if (!darg) {
61013     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61014     return 0;
61015   }
61016   {
61017     try {
61018       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61019     } catch (std::out_of_range& e) {
61020       {
61021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61022       };
61023     } catch (std::exception& e) {
61024       {
61025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61026       };
61027     } catch (Dali::DaliException e) {
61028       {
61029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61030       };
61031     } catch (...) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61034       };
61035     }
61036   }
61037
61038   jresult = result;
61039   return jresult;
61040 }
61041
61042
61043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61044   unsigned int jresult ;
61045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61046   Dali::WheelEvent *arg2 = 0 ;
61047   SwigDirector_ViewImpl *darg = 0;
61048   bool result;
61049
61050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61051   arg2 = (Dali::WheelEvent *)jarg2;
61052   if (!arg2) {
61053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61054     return 0;
61055   }
61056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61057   if (!darg) {
61058     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61059     return 0;
61060   }
61061   {
61062     try {
61063       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61064     } catch (std::out_of_range& e) {
61065       {
61066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61067       };
61068     } catch (std::exception& e) {
61069       {
61070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (Dali::DaliException e) {
61073       {
61074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61079       };
61080     }
61081   }
61082
61083   jresult = result;
61084   return jresult;
61085 }
61086
61087
61088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61090   Dali::Vector2 *arg2 = 0 ;
61091   Dali::RelayoutContainer *arg3 = 0 ;
61092   SwigDirector_ViewImpl *darg = 0;
61093
61094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61095   arg2 = (Dali::Vector2 *)jarg2;
61096   if (!arg2) {
61097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61098     return ;
61099   }
61100   arg3 = (Dali::RelayoutContainer *)jarg3;
61101   if (!arg3) {
61102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61103     return ;
61104   }
61105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61106   if (!darg) {
61107     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61108     return;
61109   }
61110   {
61111     try {
61112       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61120       };
61121     } catch (Dali::DaliException e) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61124       };
61125     } catch (...) {
61126       {
61127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61128       };
61129     }
61130   }
61131
61132 }
61133
61134
61135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(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   if (!darg) {
61154     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61155     return;
61156   }
61157   {
61158     try {
61159       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61160     } catch (std::out_of_range& e) {
61161       {
61162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61163       };
61164     } catch (std::exception& e) {
61165       {
61166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61167       };
61168     } catch (Dali::DaliException e) {
61169       {
61170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61171       };
61172     } catch (...) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61175       };
61176     }
61177   }
61178
61179 }
61180
61181
61182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61184   Dali::ResizePolicy::Type arg2 ;
61185   Dali::Dimension::Type arg3 ;
61186   SwigDirector_ViewImpl *darg = 0;
61187
61188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61189   arg2 = (Dali::ResizePolicy::Type)jarg2;
61190   arg3 = (Dali::Dimension::Type)jarg3;
61191   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61192   if (!darg) {
61193     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61194     return;
61195   }
61196   {
61197     try {
61198       (darg)->OnSetResizePolicy(arg2,arg3);
61199     } catch (std::out_of_range& e) {
61200       {
61201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61202       };
61203     } catch (std::exception& e) {
61204       {
61205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61206       };
61207     } catch (Dali::DaliException e) {
61208       {
61209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61210       };
61211     } catch (...) {
61212       {
61213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61214       };
61215     }
61216   }
61217
61218 }
61219
61220
61221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61223   Dali::ResizePolicy::Type arg2 ;
61224   Dali::Dimension::Type arg3 ;
61225   SwigDirector_ViewImpl *darg = 0;
61226
61227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61228   arg2 = (Dali::ResizePolicy::Type)jarg2;
61229   arg3 = (Dali::Dimension::Type)jarg3;
61230   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61231   if (!darg) {
61232     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61233     return;
61234   }
61235   {
61236     try {
61237       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61238     } catch (std::out_of_range& e) {
61239       {
61240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61241       };
61242     } catch (std::exception& e) {
61243       {
61244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61245       };
61246     } catch (Dali::DaliException e) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61253       };
61254     }
61255   }
61256
61257 }
61258
61259
61260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61261   void * jresult ;
61262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61263   SwigDirector_ViewImpl *darg = 0;
61264   Dali::Vector3 result;
61265
61266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61268   if (!darg) {
61269     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61270     return 0;
61271   }
61272   {
61273     try {
61274       result = (darg)->GetNaturalSize();
61275     } catch (std::out_of_range& e) {
61276       {
61277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61278       };
61279     } catch (std::exception& e) {
61280       {
61281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61282       };
61283     } catch (Dali::DaliException e) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61286       };
61287     } catch (...) {
61288       {
61289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61290       };
61291     }
61292   }
61293
61294   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61295   return jresult;
61296 }
61297
61298
61299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61300   void * jresult ;
61301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61302   SwigDirector_ViewImpl *darg = 0;
61303   Dali::Vector3 result;
61304
61305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61306   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61307   if (!darg) {
61308     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61309     return 0;
61310   }
61311   {
61312     try {
61313       result = (darg)->GetNaturalSizeSwigPublic();
61314     } catch (std::out_of_range& e) {
61315       {
61316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61317       };
61318     } catch (std::exception& e) {
61319       {
61320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (Dali::DaliException e) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61325       };
61326     } catch (...) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61329       };
61330     }
61331   }
61332
61333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61334   return jresult;
61335 }
61336
61337
61338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61339   float jresult ;
61340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61341   Dali::Actor *arg2 = 0 ;
61342   Dali::Dimension::Type arg3 ;
61343   SwigDirector_ViewImpl *darg = 0;
61344   float result;
61345
61346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61347   arg2 = (Dali::Actor *)jarg2;
61348   if (!arg2) {
61349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61350     return 0;
61351   }
61352   arg3 = (Dali::Dimension::Type)jarg3;
61353   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61354   if (!darg) {
61355     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61356     return 0;
61357   }
61358   {
61359     try {
61360       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (Dali::DaliException e) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61372       };
61373     } catch (...) {
61374       {
61375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61376       };
61377     }
61378   }
61379
61380   jresult = result;
61381   return jresult;
61382 }
61383
61384
61385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61386   float jresult ;
61387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61388   Dali::Actor *arg2 = 0 ;
61389   Dali::Dimension::Type arg3 ;
61390   SwigDirector_ViewImpl *darg = 0;
61391   float result;
61392
61393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61394   arg2 = (Dali::Actor *)jarg2;
61395   if (!arg2) {
61396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61397     return 0;
61398   }
61399   arg3 = (Dali::Dimension::Type)jarg3;
61400   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61401   if (!darg) {
61402     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61403     return 0;
61404   }
61405   {
61406     try {
61407       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61408     } catch (std::out_of_range& e) {
61409       {
61410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61411       };
61412     } catch (std::exception& e) {
61413       {
61414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61415       };
61416     } catch (Dali::DaliException e) {
61417       {
61418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61419       };
61420     } catch (...) {
61421       {
61422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61423       };
61424     }
61425   }
61426
61427   jresult = result;
61428   return jresult;
61429 }
61430
61431
61432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61433   float jresult ;
61434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61435   float arg2 ;
61436   SwigDirector_ViewImpl *darg = 0;
61437   float result;
61438
61439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61440   arg2 = (float)jarg2;
61441   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61442   if (!darg) {
61443     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61444     return 0;
61445   }
61446   {
61447     try {
61448       result = (float)(darg)->GetHeightForWidth(arg2);
61449     } catch (std::out_of_range& e) {
61450       {
61451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61452       };
61453     } catch (std::exception& e) {
61454       {
61455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61456       };
61457     } catch (Dali::DaliException e) {
61458       {
61459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61464       };
61465     }
61466   }
61467
61468   jresult = result;
61469   return jresult;
61470 }
61471
61472
61473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61474   float jresult ;
61475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61476   float arg2 ;
61477   SwigDirector_ViewImpl *darg = 0;
61478   float result;
61479
61480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61481   arg2 = (float)jarg2;
61482   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61483   if (!darg) {
61484     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61485     return 0;
61486   }
61487   {
61488     try {
61489       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61490     } catch (std::out_of_range& e) {
61491       {
61492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61493       };
61494     } catch (std::exception& e) {
61495       {
61496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61497       };
61498     } catch (Dali::DaliException e) {
61499       {
61500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61501       };
61502     } catch (...) {
61503       {
61504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61505       };
61506     }
61507   }
61508
61509   jresult = result;
61510   return jresult;
61511 }
61512
61513
61514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61515   float jresult ;
61516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61517   float arg2 ;
61518   SwigDirector_ViewImpl *darg = 0;
61519   float result;
61520
61521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61522   arg2 = (float)jarg2;
61523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61524   if (!darg) {
61525     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61526     return 0;
61527   }
61528   {
61529     try {
61530       result = (float)(darg)->GetWidthForHeight(arg2);
61531     } catch (std::out_of_range& e) {
61532       {
61533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61534       };
61535     } catch (std::exception& e) {
61536       {
61537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (Dali::DaliException e) {
61540       {
61541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61542       };
61543     } catch (...) {
61544       {
61545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61546       };
61547     }
61548   }
61549
61550   jresult = result;
61551   return jresult;
61552 }
61553
61554
61555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61556   float jresult ;
61557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61558   float arg2 ;
61559   SwigDirector_ViewImpl *darg = 0;
61560   float result;
61561
61562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61563   arg2 = (float)jarg2;
61564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61565   if (!darg) {
61566     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61567     return 0;
61568   }
61569   {
61570     try {
61571       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61572     } catch (std::out_of_range& e) {
61573       {
61574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61575       };
61576     } catch (std::exception& e) {
61577       {
61578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61579       };
61580     } catch (Dali::DaliException e) {
61581       {
61582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61583       };
61584     } catch (...) {
61585       {
61586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61587       };
61588     }
61589   }
61590
61591   jresult = result;
61592   return jresult;
61593 }
61594
61595
61596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61597   unsigned int jresult ;
61598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61599   Dali::Dimension::Type arg2 ;
61600   SwigDirector_ViewImpl *darg = 0;
61601   bool result;
61602
61603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61604   arg2 = (Dali::Dimension::Type)jarg2;
61605   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61606   if (!darg) {
61607     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61608     return 0;
61609   }
61610   {
61611     try {
61612       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61613     } catch (std::out_of_range& e) {
61614       {
61615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61616       };
61617     } catch (std::exception& e) {
61618       {
61619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61620       };
61621     } catch (Dali::DaliException e) {
61622       {
61623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61624       };
61625     } catch (...) {
61626       {
61627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61628       };
61629     }
61630   }
61631
61632   jresult = result;
61633   return jresult;
61634 }
61635
61636
61637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61638   unsigned int jresult ;
61639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61640   Dali::Dimension::Type arg2 ;
61641   SwigDirector_ViewImpl *darg = 0;
61642   bool result;
61643
61644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61645   arg2 = (Dali::Dimension::Type)jarg2;
61646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61647   if (!darg) {
61648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61649     return 0;
61650   }
61651   {
61652     try {
61653       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61654     } catch (std::out_of_range& e) {
61655       {
61656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61657       };
61658     } catch (std::exception& e) {
61659       {
61660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (Dali::DaliException e) {
61663       {
61664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61665       };
61666     } catch (...) {
61667       {
61668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61669       };
61670     }
61671   }
61672
61673   jresult = result;
61674   return jresult;
61675 }
61676
61677
61678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61679   unsigned int jresult ;
61680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61681   SwigDirector_ViewImpl *darg = 0;
61682   bool result;
61683
61684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61686   if (!darg) {
61687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61688     return 0;
61689   }
61690   {
61691     try {
61692       result = (bool)(darg)->RelayoutDependentOnChildren();
61693     } catch (std::out_of_range& e) {
61694       {
61695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61696       };
61697     } catch (std::exception& e) {
61698       {
61699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61700       };
61701     } catch (Dali::DaliException e) {
61702       {
61703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61704       };
61705     } catch (...) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61708       };
61709     }
61710   }
61711
61712   jresult = result;
61713   return jresult;
61714 }
61715
61716
61717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61718   unsigned int jresult ;
61719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61720   SwigDirector_ViewImpl *darg = 0;
61721   bool result;
61722
61723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61725   if (!darg) {
61726     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61727     return 0;
61728   }
61729   {
61730     try {
61731       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61732     } catch (std::out_of_range& e) {
61733       {
61734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61735       };
61736     } catch (std::exception& e) {
61737       {
61738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61739       };
61740     } catch (Dali::DaliException e) {
61741       {
61742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61743       };
61744     } catch (...) {
61745       {
61746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61747       };
61748     }
61749   }
61750
61751   jresult = result;
61752   return jresult;
61753 }
61754
61755
61756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61758   Dali::Dimension::Type arg2 ;
61759   SwigDirector_ViewImpl *darg = 0;
61760
61761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61762   arg2 = (Dali::Dimension::Type)jarg2;
61763   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61764   if (!darg) {
61765     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61766     return;
61767   }
61768   {
61769     try {
61770       (darg)->OnCalculateRelayoutSize(arg2);
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61778       };
61779     } catch (Dali::DaliException e) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61782       };
61783     } catch (...) {
61784       {
61785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61786       };
61787     }
61788   }
61789
61790 }
61791
61792
61793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61795   Dali::Dimension::Type arg2 ;
61796   SwigDirector_ViewImpl *darg = 0;
61797
61798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61799   arg2 = (Dali::Dimension::Type)jarg2;
61800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61801   if (!darg) {
61802     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61803     return;
61804   }
61805   {
61806     try {
61807       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61808     } catch (std::out_of_range& e) {
61809       {
61810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61811       };
61812     } catch (std::exception& e) {
61813       {
61814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61815       };
61816     } catch (Dali::DaliException e) {
61817       {
61818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61819       };
61820     } catch (...) {
61821       {
61822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61823       };
61824     }
61825   }
61826
61827 }
61828
61829
61830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61832   float arg2 ;
61833   Dali::Dimension::Type arg3 ;
61834   SwigDirector_ViewImpl *darg = 0;
61835
61836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61837   arg2 = (float)jarg2;
61838   arg3 = (Dali::Dimension::Type)jarg3;
61839   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61840   if (!darg) {
61841     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61842     return;
61843   }
61844   {
61845     try {
61846       (darg)->OnLayoutNegotiated(arg2,arg3);
61847     } catch (std::out_of_range& e) {
61848       {
61849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61850       };
61851     } catch (std::exception& e) {
61852       {
61853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61854       };
61855     } catch (Dali::DaliException e) {
61856       {
61857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61858       };
61859     } catch (...) {
61860       {
61861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61862       };
61863     }
61864   }
61865
61866 }
61867
61868
61869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61871   float arg2 ;
61872   Dali::Dimension::Type arg3 ;
61873   SwigDirector_ViewImpl *darg = 0;
61874
61875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61876   arg2 = (float)jarg2;
61877   arg3 = (Dali::Dimension::Type)jarg3;
61878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61879   if (!darg) {
61880     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61881     return;
61882   }
61883   {
61884     try {
61885       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61886     } catch (std::out_of_range& e) {
61887       {
61888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61889       };
61890     } catch (std::exception& e) {
61891       {
61892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61893       };
61894     } catch (Dali::DaliException e) {
61895       {
61896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61897       };
61898     } catch (...) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61901       };
61902     }
61903   }
61904
61905 }
61906
61907
61908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61910
61911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61912   {
61913     try {
61914       (arg1)->OnInitialize();
61915     } catch (std::out_of_range& e) {
61916       {
61917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61918       };
61919     } catch (std::exception& e) {
61920       {
61921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61922       };
61923     } catch (Dali::DaliException e) {
61924       {
61925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61926       };
61927     } catch (...) {
61928       {
61929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61930       };
61931     }
61932   }
61933
61934 }
61935
61936
61937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   {
61942     try {
61943       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61944     } catch (std::out_of_range& e) {
61945       {
61946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61947       };
61948     } catch (std::exception& e) {
61949       {
61950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61951       };
61952     } catch (Dali::DaliException e) {
61953       {
61954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61955       };
61956     } catch (...) {
61957       {
61958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61959       };
61960     }
61961   }
61962
61963 }
61964
61965
61966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61968   Dali::Toolkit::StyleManager arg2 ;
61969   Dali::StyleChange::Type arg3 ;
61970   Dali::Toolkit::StyleManager *argp2 ;
61971
61972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61973   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61974   if (!argp2) {
61975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61976     return ;
61977   }
61978   arg2 = *argp2;
61979   arg3 = (Dali::StyleChange::Type)jarg3;
61980   {
61981     try {
61982       (arg1)->OnStyleChange(arg2,arg3);
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61990       };
61991     } catch (Dali::DaliException e) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61994       };
61995     } catch (...) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61998       };
61999     }
62000   }
62001
62002 }
62003
62004
62005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62007   Dali::Toolkit::StyleManager arg2 ;
62008   Dali::StyleChange::Type arg3 ;
62009   Dali::Toolkit::StyleManager *argp2 ;
62010
62011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62012   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62013   if (!argp2) {
62014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62015     return ;
62016   }
62017   arg2 = *argp2;
62018   arg3 = (Dali::StyleChange::Type)jarg3;
62019   {
62020     try {
62021       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62029       };
62030     } catch (Dali::DaliException e) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62037       };
62038     }
62039   }
62040
62041 }
62042
62043
62044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62045   unsigned int jresult ;
62046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62047   bool result;
62048
62049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62050   {
62051     try {
62052       result = (bool)(arg1)->OnAccessibilityActivated();
62053     } catch (std::out_of_range& e) {
62054       {
62055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62056       };
62057     } catch (std::exception& e) {
62058       {
62059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (Dali::DaliException e) {
62062       {
62063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62064       };
62065     } catch (...) {
62066       {
62067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62068       };
62069     }
62070   }
62071
62072   jresult = result;
62073   return jresult;
62074 }
62075
62076
62077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62078   unsigned int jresult ;
62079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62080   bool result;
62081
62082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62083   {
62084     try {
62085       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62086     } catch (std::out_of_range& e) {
62087       {
62088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62089       };
62090     } catch (std::exception& e) {
62091       {
62092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (Dali::DaliException e) {
62095       {
62096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62097       };
62098     } catch (...) {
62099       {
62100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62101       };
62102     }
62103   }
62104
62105   jresult = result;
62106   return jresult;
62107 }
62108
62109
62110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62111   unsigned int jresult ;
62112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62113   Dali::PanGesture arg2 ;
62114   Dali::PanGesture *argp2 ;
62115   bool result;
62116
62117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62118   argp2 = (Dali::PanGesture *)jarg2;
62119   if (!argp2) {
62120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62121     return 0;
62122   }
62123   arg2 = *argp2;
62124   {
62125     try {
62126       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62127     } catch (std::out_of_range& e) {
62128       {
62129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62130       };
62131     } catch (std::exception& e) {
62132       {
62133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62134       };
62135     } catch (Dali::DaliException e) {
62136       {
62137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62138       };
62139     } catch (...) {
62140       {
62141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62142       };
62143     }
62144   }
62145
62146   jresult = result;
62147   return jresult;
62148 }
62149
62150
62151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62152   unsigned int jresult ;
62153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62154   Dali::PanGesture arg2 ;
62155   Dali::PanGesture *argp2 ;
62156   bool result;
62157
62158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62159   argp2 = (Dali::PanGesture *)jarg2;
62160   if (!argp2) {
62161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62162     return 0;
62163   }
62164   arg2 = *argp2;
62165   {
62166     try {
62167       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62168     } catch (std::out_of_range& e) {
62169       {
62170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62171       };
62172     } catch (std::exception& e) {
62173       {
62174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62175       };
62176     } catch (Dali::DaliException e) {
62177       {
62178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62179       };
62180     } catch (...) {
62181       {
62182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62183       };
62184     }
62185   }
62186
62187   jresult = result;
62188   return jresult;
62189 }
62190
62191
62192
62193
62194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62195   unsigned int jresult ;
62196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62197   bool arg2 ;
62198   bool result;
62199
62200   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62201   arg2 = jarg2 ? true : false;
62202   {
62203     try {
62204       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62205     } catch (std::out_of_range& e) {
62206       {
62207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62208       };
62209     } catch (std::exception& e) {
62210       {
62211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62212       };
62213     } catch (Dali::DaliException e) {
62214       {
62215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62216       };
62217     } catch (...) {
62218       {
62219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62220       };
62221     }
62222   }
62223
62224   jresult = result;
62225   return jresult;
62226 }
62227
62228
62229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62230   unsigned int jresult ;
62231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62232   bool arg2 ;
62233   bool result;
62234
62235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62236   arg2 = jarg2 ? true : false;
62237   {
62238     try {
62239       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62240     } catch (std::out_of_range& e) {
62241       {
62242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62243       };
62244     } catch (std::exception& e) {
62245       {
62246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62247       };
62248     } catch (Dali::DaliException e) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62251       };
62252     } catch (...) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62255       };
62256     }
62257   }
62258
62259   jresult = result;
62260   return jresult;
62261 }
62262
62263
62264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62265   unsigned int jresult ;
62266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62267   bool result;
62268
62269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62270   {
62271     try {
62272       result = (bool)(arg1)->OnAccessibilityZoom();
62273     } catch (std::out_of_range& e) {
62274       {
62275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62276       };
62277     } catch (std::exception& e) {
62278       {
62279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62280       };
62281     } catch (Dali::DaliException e) {
62282       {
62283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62284       };
62285     } catch (...) {
62286       {
62287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62288       };
62289     }
62290   }
62291
62292   jresult = result;
62293   return jresult;
62294 }
62295
62296
62297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62298   unsigned int jresult ;
62299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62300   bool result;
62301
62302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62303   {
62304     try {
62305       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62306     } catch (std::out_of_range& e) {
62307       {
62308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62309       };
62310     } catch (std::exception& e) {
62311       {
62312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62313       };
62314     } catch (Dali::DaliException e) {
62315       {
62316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62317       };
62318     } catch (...) {
62319       {
62320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62321       };
62322     }
62323   }
62324
62325   jresult = result;
62326   return jresult;
62327 }
62328
62329
62330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62332
62333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62334   {
62335     try {
62336       (arg1)->OnKeyInputFocusGained();
62337     } catch (std::out_of_range& e) {
62338       {
62339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62340       };
62341     } catch (std::exception& e) {
62342       {
62343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62344       };
62345     } catch (Dali::DaliException e) {
62346       {
62347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62348       };
62349     } catch (...) {
62350       {
62351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62352       };
62353     }
62354   }
62355
62356 }
62357
62358
62359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62361
62362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62363   {
62364     try {
62365       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62366     } catch (std::out_of_range& e) {
62367       {
62368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62369       };
62370     } catch (std::exception& e) {
62371       {
62372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62373       };
62374     } catch (Dali::DaliException e) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62377       };
62378     } catch (...) {
62379       {
62380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62381       };
62382     }
62383   }
62384
62385 }
62386
62387
62388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62390
62391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62392   {
62393     try {
62394       (arg1)->OnKeyInputFocusLost();
62395     } catch (std::out_of_range& e) {
62396       {
62397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62398       };
62399     } catch (std::exception& e) {
62400       {
62401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62402       };
62403     } catch (Dali::DaliException e) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62406       };
62407     } catch (...) {
62408       {
62409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62410       };
62411     }
62412   }
62413
62414 }
62415
62416
62417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62419
62420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62421   {
62422     try {
62423       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62424     } catch (std::out_of_range& e) {
62425       {
62426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62427       };
62428     } catch (std::exception& e) {
62429       {
62430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62431       };
62432     } catch (Dali::DaliException e) {
62433       {
62434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62435       };
62436     } catch (...) {
62437       {
62438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62439       };
62440     }
62441   }
62442
62443 }
62444
62445
62446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62447   void * jresult ;
62448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62449   Dali::Actor arg2 ;
62450   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62451   bool arg4 ;
62452   Dali::Actor *argp2 ;
62453   Dali::Actor result;
62454
62455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62456   argp2 = (Dali::Actor *)jarg2;
62457   if (!argp2) {
62458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62459     return 0;
62460   }
62461   arg2 = *argp2;
62462   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62463   arg4 = jarg4 ? true : false;
62464   {
62465     try {
62466       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62467     } catch (std::out_of_range& e) {
62468       {
62469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62470       };
62471     } catch (std::exception& e) {
62472       {
62473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62474       };
62475     } catch (Dali::DaliException e) {
62476       {
62477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62478       };
62479     } catch (...) {
62480       {
62481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62482       };
62483     }
62484   }
62485
62486   jresult = new Dali::Actor((const Dali::Actor &)result);
62487   return jresult;
62488 }
62489
62490
62491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62492   void * jresult ;
62493   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62494   Dali::Actor arg2 ;
62495   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62496   bool arg4 ;
62497   Dali::Actor *argp2 ;
62498   Dali::Actor result;
62499
62500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62501   argp2 = (Dali::Actor *)jarg2;
62502   if (!argp2) {
62503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62504     return 0;
62505   }
62506   arg2 = *argp2;
62507   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62508   arg4 = jarg4 ? true : false;
62509   {
62510     try {
62511       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62512     } catch (std::out_of_range& e) {
62513       {
62514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62515       };
62516     } catch (std::exception& e) {
62517       {
62518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62519       };
62520     } catch (Dali::DaliException e) {
62521       {
62522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62523       };
62524     } catch (...) {
62525       {
62526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62527       };
62528     }
62529   }
62530
62531   jresult = new Dali::Actor((const Dali::Actor &)result);
62532   return jresult;
62533 }
62534
62535
62536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62538   Dali::Actor arg2 ;
62539   Dali::Actor *argp2 ;
62540
62541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62542   argp2 = (Dali::Actor *)jarg2;
62543   if (!argp2) {
62544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62545     return ;
62546   }
62547   arg2 = *argp2;
62548   {
62549     try {
62550       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62551     } catch (std::out_of_range& e) {
62552       {
62553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62554       };
62555     } catch (std::exception& e) {
62556       {
62557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62558       };
62559     } catch (Dali::DaliException e) {
62560       {
62561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62562       };
62563     } catch (...) {
62564       {
62565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62566       };
62567     }
62568   }
62569
62570 }
62571
62572
62573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62575   Dali::Actor arg2 ;
62576   Dali::Actor *argp2 ;
62577
62578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62579   argp2 = (Dali::Actor *)jarg2;
62580   if (!argp2) {
62581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62582     return ;
62583   }
62584   arg2 = *argp2;
62585   {
62586     try {
62587       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62588     } catch (std::out_of_range& e) {
62589       {
62590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62591       };
62592     } catch (std::exception& e) {
62593       {
62594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62595       };
62596     } catch (Dali::DaliException e) {
62597       {
62598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62603       };
62604     }
62605   }
62606
62607 }
62608
62609
62610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62611   unsigned int jresult ;
62612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62613   bool result;
62614
62615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62616   {
62617     try {
62618       result = (bool)(arg1)->OnKeyboardEnter();
62619     } catch (std::out_of_range& e) {
62620       {
62621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (std::exception& e) {
62624       {
62625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62626       };
62627     } catch (Dali::DaliException e) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62630       };
62631     } catch (...) {
62632       {
62633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62634       };
62635     }
62636   }
62637
62638   jresult = result;
62639   return jresult;
62640 }
62641
62642
62643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62644   unsigned int jresult ;
62645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62646   bool result;
62647
62648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62649   {
62650     try {
62651       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62652     } catch (std::out_of_range& e) {
62653       {
62654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62655       };
62656     } catch (std::exception& e) {
62657       {
62658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (Dali::DaliException e) {
62661       {
62662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62663       };
62664     } catch (...) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62667       };
62668     }
62669   }
62670
62671   jresult = result;
62672   return jresult;
62673 }
62674
62675
62676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62678   Dali::PinchGesture *arg2 = 0 ;
62679
62680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62681   arg2 = (Dali::PinchGesture *)jarg2;
62682   if (!arg2) {
62683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62684     return ;
62685   }
62686   {
62687     try {
62688       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62689     } catch (std::out_of_range& e) {
62690       {
62691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62692       };
62693     } catch (std::exception& e) {
62694       {
62695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62696       };
62697     } catch (Dali::DaliException e) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62700       };
62701     } catch (...) {
62702       {
62703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62704       };
62705     }
62706   }
62707
62708 }
62709
62710
62711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62713   Dali::PinchGesture *arg2 = 0 ;
62714
62715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62716   arg2 = (Dali::PinchGesture *)jarg2;
62717   if (!arg2) {
62718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62719     return ;
62720   }
62721   {
62722     try {
62723       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62724     } catch (std::out_of_range& e) {
62725       {
62726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62727       };
62728     } catch (std::exception& e) {
62729       {
62730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62731       };
62732     } catch (Dali::DaliException e) {
62733       {
62734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62735       };
62736     } catch (...) {
62737       {
62738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62739       };
62740     }
62741   }
62742
62743 }
62744
62745
62746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62748   Dali::PanGesture *arg2 = 0 ;
62749
62750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62751   arg2 = (Dali::PanGesture *)jarg2;
62752   if (!arg2) {
62753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62754     return ;
62755   }
62756   {
62757     try {
62758       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62759     } catch (std::out_of_range& e) {
62760       {
62761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62762       };
62763     } catch (std::exception& e) {
62764       {
62765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62766       };
62767     } catch (Dali::DaliException e) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62770       };
62771     } catch (...) {
62772       {
62773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62774       };
62775     }
62776   }
62777
62778 }
62779
62780
62781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62783   Dali::PanGesture *arg2 = 0 ;
62784
62785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62786   arg2 = (Dali::PanGesture *)jarg2;
62787   if (!arg2) {
62788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62789     return ;
62790   }
62791   {
62792     try {
62793       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62794     } catch (std::out_of_range& e) {
62795       {
62796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62797       };
62798     } catch (std::exception& e) {
62799       {
62800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62801       };
62802     } catch (Dali::DaliException e) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62805       };
62806     } catch (...) {
62807       {
62808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62809       };
62810     }
62811   }
62812
62813 }
62814
62815
62816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62818   Dali::TapGesture *arg2 = 0 ;
62819
62820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62821   arg2 = (Dali::TapGesture *)jarg2;
62822   if (!arg2) {
62823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62824     return ;
62825   }
62826   {
62827     try {
62828       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62829     } catch (std::out_of_range& e) {
62830       {
62831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62832       };
62833     } catch (std::exception& e) {
62834       {
62835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62836       };
62837     } catch (Dali::DaliException e) {
62838       {
62839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62840       };
62841     } catch (...) {
62842       {
62843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62844       };
62845     }
62846   }
62847
62848 }
62849
62850
62851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62853   Dali::TapGesture *arg2 = 0 ;
62854
62855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62856   arg2 = (Dali::TapGesture *)jarg2;
62857   if (!arg2) {
62858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62859     return ;
62860   }
62861   {
62862     try {
62863       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62864     } catch (std::out_of_range& e) {
62865       {
62866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62867       };
62868     } catch (std::exception& e) {
62869       {
62870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62871       };
62872     } catch (Dali::DaliException e) {
62873       {
62874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62875       };
62876     } catch (...) {
62877       {
62878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62879       };
62880     }
62881   }
62882
62883 }
62884
62885
62886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62888   Dali::LongPressGesture *arg2 = 0 ;
62889
62890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62891   arg2 = (Dali::LongPressGesture *)jarg2;
62892   if (!arg2) {
62893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62894     return ;
62895   }
62896   {
62897     try {
62898       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62899     } catch (std::out_of_range& e) {
62900       {
62901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62902       };
62903     } catch (std::exception& e) {
62904       {
62905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62906       };
62907     } catch (Dali::DaliException e) {
62908       {
62909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62910       };
62911     } catch (...) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62914       };
62915     }
62916   }
62917
62918 }
62919
62920
62921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62923   Dali::LongPressGesture *arg2 = 0 ;
62924
62925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62926   arg2 = (Dali::LongPressGesture *)jarg2;
62927   if (!arg2) {
62928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62929     return ;
62930   }
62931   {
62932     try {
62933       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62934     } catch (std::out_of_range& e) {
62935       {
62936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62937       };
62938     } catch (std::exception& e) {
62939       {
62940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62941       };
62942     } catch (Dali::DaliException e) {
62943       {
62944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62949       };
62950     }
62951   }
62952
62953 }
62954
62955
62956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62958   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62959   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62960
62961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62962   arg2 = (Dali::SlotObserver *)jarg2;
62963   arg3 = (Dali::CallbackBase *)jarg3;
62964   {
62965     try {
62966       (arg1)->SignalConnected(arg2,arg3);
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62974       };
62975     } catch (Dali::DaliException e) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62982       };
62983     }
62984   }
62985
62986 }
62987
62988
62989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62991   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62992   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62993
62994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62995   arg2 = (Dali::SlotObserver *)jarg2;
62996   arg3 = (Dali::CallbackBase *)jarg3;
62997   {
62998     try {
62999       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63000     } catch (std::out_of_range& e) {
63001       {
63002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63003       };
63004     } catch (std::exception& e) {
63005       {
63006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63007       };
63008     } catch (Dali::DaliException e) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63011       };
63012     } catch (...) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63015       };
63016     }
63017   }
63018
63019 }
63020
63021
63022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63024   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63025   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63026
63027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63028   arg2 = (Dali::SlotObserver *)jarg2;
63029   arg3 = (Dali::CallbackBase *)jarg3;
63030   {
63031     try {
63032       (arg1)->SignalDisconnected(arg2,arg3);
63033     } catch (std::out_of_range& e) {
63034       {
63035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63036       };
63037     } catch (std::exception& e) {
63038       {
63039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63040       };
63041     } catch (Dali::DaliException e) {
63042       {
63043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63044       };
63045     } catch (...) {
63046       {
63047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63048       };
63049     }
63050   }
63051
63052 }
63053
63054
63055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63057   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63058   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63059
63060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63061   arg2 = (Dali::SlotObserver *)jarg2;
63062   arg3 = (Dali::CallbackBase *)jarg3;
63063   {
63064     try {
63065       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63066     } catch (std::out_of_range& e) {
63067       {
63068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63069       };
63070     } catch (std::exception& e) {
63071       {
63072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63073       };
63074     } catch (Dali::DaliException e) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63077       };
63078     } catch (...) {
63079       {
63080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63081       };
63082     }
63083   }
63084
63085 }
63086
63087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_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_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, 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) {
63088   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63089   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63090   if (director) {
63091     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
63092   }
63093 }
63094
63095
63096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63097   void * jresult ;
63098   Dali::Toolkit::Control *arg1 = 0 ;
63099   Dali::Toolkit::Internal::Control *result = 0 ;
63100
63101   arg1 = (Dali::Toolkit::Control *)jarg1;
63102   if (!arg1) {
63103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63104     return 0;
63105   }
63106   {
63107     try {
63108       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63109     } catch (std::out_of_range& e) {
63110       {
63111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (std::exception& e) {
63114       {
63115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63116       };
63117     } catch (Dali::DaliException e) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63120       };
63121     } catch (...) {
63122       {
63123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63124       };
63125     }
63126   }
63127
63128   jresult = (void *)result;
63129   return jresult;
63130 }
63131
63132
63133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63134   int jresult ;
63135   int result;
63136
63137   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63138   jresult = (int)result;
63139   return jresult;
63140 }
63141
63142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63143   int jresult ;
63144   int result;
63145
63146   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63147   jresult = (int)result;
63148   return jresult;
63149 }
63150
63151
63152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63153   int jresult ;
63154   int result;
63155
63156   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63157   jresult = (int)result;
63158   return jresult;
63159 }
63160
63161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
63162   int jresult ;
63163   int result;
63164
63165   result = (int)Dali::Toolkit::Control::Property::MARGIN;
63166   jresult = (int)result;
63167   return jresult;
63168 }
63169
63170
63171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
63172   int jresult ;
63173   int result;
63174
63175   result = (int)Dali::Toolkit::Control::Property::PADDING;
63176   jresult = (int)result;
63177   return jresult;
63178 }
63179
63180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63181   int jresult ;
63182   int result;
63183
63184   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63185   jresult = (int)result;
63186   return jresult;
63187 }
63188
63189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63190   void * jresult ;
63191   Dali::Toolkit::Control::Property *result = 0 ;
63192
63193   {
63194     try {
63195       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63196     } catch (std::out_of_range& e) {
63197       {
63198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63199       };
63200     } catch (std::exception& e) {
63201       {
63202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63203       };
63204     } catch (Dali::DaliException e) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63207       };
63208     } catch (...) {
63209       {
63210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63211       };
63212     }
63213   }
63214
63215   jresult = (void *)result;
63216   return jresult;
63217 }
63218
63219
63220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63221   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63222
63223   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63224   {
63225     try {
63226       delete arg1;
63227     } catch (std::out_of_range& e) {
63228       {
63229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63230       };
63231     } catch (std::exception& e) {
63232       {
63233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63234       };
63235     } catch (Dali::DaliException e) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63238       };
63239     } catch (...) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63242       };
63243     }
63244   }
63245
63246 }
63247
63248
63249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63250   void * jresult ;
63251   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63252
63253   {
63254     try {
63255       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63256     } catch (std::out_of_range& e) {
63257       {
63258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63259       };
63260     } catch (std::exception& e) {
63261       {
63262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (Dali::DaliException e) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63267       };
63268     } catch (...) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63271       };
63272     }
63273   }
63274
63275   jresult = (void *)result;
63276   return jresult;
63277 }
63278
63279
63280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63281   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63282
63283   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63284   {
63285     try {
63286       delete arg1;
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63294       };
63295     } catch (Dali::DaliException e) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63302       };
63303     }
63304   }
63305
63306 }
63307
63308
63309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63310   void * jresult ;
63311   Dali::Toolkit::Control result;
63312
63313   {
63314     try {
63315       result = Dali::Toolkit::Control::New();
63316     } catch (std::out_of_range& e) {
63317       {
63318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63319       };
63320     } catch (std::exception& e) {
63321       {
63322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (Dali::DaliException e) {
63325       {
63326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63327       };
63328     } catch (...) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63331       };
63332     }
63333   }
63334
63335   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63336   return jresult;
63337 }
63338
63339
63340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63341   void * jresult ;
63342   Dali::Toolkit::Control *result = 0 ;
63343
63344   {
63345     try {
63346       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63354       };
63355     } catch (Dali::DaliException e) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63358       };
63359     } catch (...) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63362       };
63363     }
63364   }
63365
63366   jresult = (void *)result;
63367   return jresult;
63368 }
63369
63370
63371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63372   void * jresult ;
63373   Dali::Toolkit::Control *arg1 = 0 ;
63374   Dali::Toolkit::Control *result = 0 ;
63375
63376   arg1 = (Dali::Toolkit::Control *)jarg1;
63377   if (!arg1) {
63378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63379     return 0;
63380   }
63381   {
63382     try {
63383       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63384     } catch (std::out_of_range& e) {
63385       {
63386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63387       };
63388     } catch (std::exception& e) {
63389       {
63390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63391       };
63392     } catch (Dali::DaliException e) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63395       };
63396     } catch (...) {
63397       {
63398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63399       };
63400     }
63401   }
63402
63403   jresult = (void *)result;
63404   return jresult;
63405 }
63406
63407
63408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63409   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63410
63411   arg1 = (Dali::Toolkit::Control *)jarg1;
63412   {
63413     try {
63414       delete arg1;
63415     } catch (std::out_of_range& e) {
63416       {
63417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63418       };
63419     } catch (std::exception& e) {
63420       {
63421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63422       };
63423     } catch (Dali::DaliException e) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63426       };
63427     } catch (...) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63430       };
63431     }
63432   }
63433
63434 }
63435
63436
63437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63438   void * jresult ;
63439   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63440   Dali::Toolkit::Control *arg2 = 0 ;
63441   Dali::Toolkit::Control *result = 0 ;
63442
63443   arg1 = (Dali::Toolkit::Control *)jarg1;
63444   arg2 = (Dali::Toolkit::Control *)jarg2;
63445   if (!arg2) {
63446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63447     return 0;
63448   }
63449   {
63450     try {
63451       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63452     } catch (std::out_of_range& e) {
63453       {
63454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63455       };
63456     } catch (std::exception& e) {
63457       {
63458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63459       };
63460     } catch (Dali::DaliException e) {
63461       {
63462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63463       };
63464     } catch (...) {
63465       {
63466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63467       };
63468     }
63469   }
63470
63471   jresult = (void *)result;
63472   return jresult;
63473 }
63474
63475
63476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63477   void * jresult ;
63478   Dali::BaseHandle arg1 ;
63479   Dali::BaseHandle *argp1 ;
63480   Dali::Toolkit::Control result;
63481
63482   argp1 = (Dali::BaseHandle *)jarg1;
63483   if (!argp1) {
63484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63485     return 0;
63486   }
63487   arg1 = *argp1;
63488   {
63489     try {
63490       result = Dali::Toolkit::Control::DownCast(arg1);
63491     } catch (std::out_of_range& e) {
63492       {
63493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63494       };
63495     } catch (std::exception& e) {
63496       {
63497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63498       };
63499     } catch (Dali::DaliException e) {
63500       {
63501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63502       };
63503     } catch (...) {
63504       {
63505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63506       };
63507     }
63508   }
63509
63510   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63511   return jresult;
63512 }
63513
63514
63515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63516   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63517
63518   arg1 = (Dali::Toolkit::Control *)jarg1;
63519   {
63520     try {
63521       (arg1)->SetKeyInputFocus();
63522     } catch (std::out_of_range& e) {
63523       {
63524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63525       };
63526     } catch (std::exception& e) {
63527       {
63528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63529       };
63530     } catch (Dali::DaliException e) {
63531       {
63532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63533       };
63534     } catch (...) {
63535       {
63536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63537       };
63538     }
63539   }
63540
63541 }
63542
63543
63544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63545   unsigned int jresult ;
63546   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63547   bool result;
63548
63549   arg1 = (Dali::Toolkit::Control *)jarg1;
63550   {
63551     try {
63552       result = (bool)(arg1)->HasKeyInputFocus();
63553     } catch (std::out_of_range& e) {
63554       {
63555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63556       };
63557     } catch (std::exception& e) {
63558       {
63559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63560       };
63561     } catch (Dali::DaliException e) {
63562       {
63563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63564       };
63565     } catch (...) {
63566       {
63567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63568       };
63569     }
63570   }
63571
63572   jresult = result;
63573   return jresult;
63574 }
63575
63576
63577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63578   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63579
63580   arg1 = (Dali::Toolkit::Control *)jarg1;
63581   {
63582     try {
63583       (arg1)->ClearKeyInputFocus();
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63591       };
63592     } catch (Dali::DaliException e) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63595       };
63596     } catch (...) {
63597       {
63598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63599       };
63600     }
63601   }
63602
63603 }
63604
63605
63606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63607   void * jresult ;
63608   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63609   Dali::PinchGestureDetector result;
63610
63611   arg1 = (Dali::Toolkit::Control *)jarg1;
63612   {
63613     try {
63614       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63615     } catch (std::out_of_range& e) {
63616       {
63617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63618       };
63619     } catch (std::exception& e) {
63620       {
63621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63622       };
63623     } catch (Dali::DaliException e) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63630       };
63631     }
63632   }
63633
63634   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63635   return jresult;
63636 }
63637
63638
63639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63640   void * jresult ;
63641   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63642   Dali::PanGestureDetector result;
63643
63644   arg1 = (Dali::Toolkit::Control *)jarg1;
63645   {
63646     try {
63647       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63648     } catch (std::out_of_range& e) {
63649       {
63650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63651       };
63652     } catch (std::exception& e) {
63653       {
63654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63655       };
63656     } catch (Dali::DaliException e) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63659       };
63660     } catch (...) {
63661       {
63662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63663       };
63664     }
63665   }
63666
63667   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63668   return jresult;
63669 }
63670
63671
63672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63673   void * jresult ;
63674   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63675   Dali::TapGestureDetector result;
63676
63677   arg1 = (Dali::Toolkit::Control *)jarg1;
63678   {
63679     try {
63680       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63681     } catch (std::out_of_range& e) {
63682       {
63683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63684       };
63685     } catch (std::exception& e) {
63686       {
63687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63688       };
63689     } catch (Dali::DaliException e) {
63690       {
63691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63692       };
63693     } catch (...) {
63694       {
63695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63696       };
63697     }
63698   }
63699
63700   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63701   return jresult;
63702 }
63703
63704
63705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63706   void * jresult ;
63707   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63708   Dali::LongPressGestureDetector result;
63709
63710   arg1 = (Dali::Toolkit::Control *)jarg1;
63711   {
63712     try {
63713       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63714     } catch (std::out_of_range& e) {
63715       {
63716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63717       };
63718     } catch (std::exception& e) {
63719       {
63720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63721       };
63722     } catch (Dali::DaliException e) {
63723       {
63724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63725       };
63726     } catch (...) {
63727       {
63728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63729       };
63730     }
63731   }
63732
63733   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63734   return jresult;
63735 }
63736
63737
63738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63740   std::string *arg2 = 0 ;
63741
63742   arg1 = (Dali::Toolkit::Control *)jarg1;
63743   if (!jarg2) {
63744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63745     return ;
63746   }
63747   std::string arg2_str(jarg2);
63748   arg2 = &arg2_str;
63749   {
63750     try {
63751       (arg1)->SetStyleName((std::string const &)*arg2);
63752     } catch (std::out_of_range& e) {
63753       {
63754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63755       };
63756     } catch (std::exception& e) {
63757       {
63758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63759       };
63760     } catch (Dali::DaliException e) {
63761       {
63762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63763       };
63764     } catch (...) {
63765       {
63766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63767       };
63768     }
63769   }
63770
63771
63772   //argout typemap for const std::string&
63773
63774 }
63775
63776
63777 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63778   char * jresult ;
63779   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63780   std::string *result = 0 ;
63781
63782   arg1 = (Dali::Toolkit::Control *)jarg1;
63783   {
63784     try {
63785       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63786     } catch (std::out_of_range& e) {
63787       {
63788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63789       };
63790     } catch (std::exception& e) {
63791       {
63792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63793       };
63794     } catch (Dali::DaliException e) {
63795       {
63796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63797       };
63798     } catch (...) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63801       };
63802     }
63803   }
63804
63805   jresult = SWIG_csharp_string_callback(result->c_str());
63806   return jresult;
63807 }
63808
63809
63810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63811   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63812   Dali::Vector4 *arg2 = 0 ;
63813
63814   arg1 = (Dali::Toolkit::Control *)jarg1;
63815   arg2 = (Dali::Vector4 *)jarg2;
63816   if (!arg2) {
63817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63818     return ;
63819   }
63820   {
63821     try {
63822       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63823     } catch (std::out_of_range& e) {
63824       {
63825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63826       };
63827     } catch (std::exception& e) {
63828       {
63829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63830       };
63831     } catch (Dali::DaliException e) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63834       };
63835     } catch (...) {
63836       {
63837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63838       };
63839     }
63840   }
63841
63842 }
63843
63844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63845   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63846
63847   arg1 = (Dali::Toolkit::Control *)jarg1;
63848   {
63849     try {
63850       (arg1)->ClearBackground();
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 (Dali::DaliException e) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63862       };
63863     } catch (...) {
63864       {
63865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63866       };
63867     }
63868   }
63869
63870 }
63871
63872
63873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63874   void * jresult ;
63875   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63876   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63877
63878   arg1 = (Dali::Toolkit::Control *)jarg1;
63879   {
63880     try {
63881       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63882     } catch (std::out_of_range& e) {
63883       {
63884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63885       };
63886     } catch (std::exception& e) {
63887       {
63888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63889       };
63890     } catch (Dali::DaliException e) {
63891       {
63892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63893       };
63894     } catch (...) {
63895       {
63896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63897       };
63898     }
63899   }
63900
63901   jresult = (void *)result;
63902   return jresult;
63903 }
63904
63905
63906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63907   void * jresult ;
63908   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63909   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63910
63911   arg1 = (Dali::Toolkit::Control *)jarg1;
63912   {
63913     try {
63914       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63915     } catch (std::out_of_range& e) {
63916       {
63917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63918       };
63919     } catch (std::exception& e) {
63920       {
63921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63922       };
63923     } catch (Dali::DaliException e) {
63924       {
63925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63926       };
63927     } catch (...) {
63928       {
63929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63930       };
63931     }
63932   }
63933
63934   jresult = (void *)result;
63935   return jresult;
63936 }
63937
63938
63939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63940   void * jresult ;
63941   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63942   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63943
63944   arg1 = (Dali::Toolkit::Control *)jarg1;
63945   {
63946     try {
63947       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63948     } catch (std::out_of_range& e) {
63949       {
63950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63951       };
63952     } catch (std::exception& e) {
63953       {
63954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63955       };
63956     } catch (Dali::DaliException e) {
63957       {
63958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63959       };
63960     } catch (...) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63963       };
63964     }
63965   }
63966
63967   jresult = (void *)result;
63968   return jresult;
63969 }
63970
63971
63972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63973   void * jresult ;
63974   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63975   Dali::Toolkit::Control *result = 0 ;
63976
63977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63978   if (!arg1) {
63979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63980     return 0;
63981   }
63982   {
63983     try {
63984       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63985     } catch (std::out_of_range& e) {
63986       {
63987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63988       };
63989     } catch (std::exception& e) {
63990       {
63991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63992       };
63993     } catch (Dali::DaliException e) {
63994       {
63995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63996       };
63997     } catch (...) {
63998       {
63999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64000       };
64001     }
64002   }
64003
64004   jresult = (void *)result;
64005   return jresult;
64006 }
64007
64008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
64009 {
64010   int jresult;
64011   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64012   arg1 = (Dali::Toolkit::Control *)jarg1;
64013
64014   if (!arg1) {
64015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64016     return 0;
64017   }
64018
64019   Dali::Property::Index arg2 = 0 ;
64020   arg2 = (Dali::Property::Index)jarg2;
64021
64022   Toolkit::Visual::ResourceStatus result;
64023   {
64024     try {
64025       result = arg1->GetVisualResourceStatus(arg2);
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (...) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64037       };
64038     }
64039   }
64040   jresult = (int)(result);
64041   return jresult;
64042 }
64043
64044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64045 {
64046   void * jresult;
64047   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64048   arg1 = (Dali::Toolkit::Control *)jarg1;
64049
64050   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64051
64052   Dali::Toolkit::TransitionData *arg2 = 0 ;
64053   Dali::Animation result;
64054
64055   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64056   if (!arg2) {
64057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64058     return 0;
64059   }
64060   {
64061     try {
64062       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64063     } catch (std::out_of_range& e) {
64064       {
64065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (std::exception& e) {
64068       {
64069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64070       };
64071     } catch (Dali::DaliException e) {
64072       {
64073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64074       };
64075     } catch (...) {
64076       {
64077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64078       };
64079     }
64080   }
64081
64082   jresult = new Dali::Animation((const Dali::Animation &)result);
64083   return jresult;
64084 }
64085
64086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
64087 {
64088   Dali::Toolkit::Control arg1;
64089   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
64090
64091   if (!argp1) {
64092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64093   }
64094   arg1 = *argp1;
64095
64096   Dali::Property::Index arg2 = 0 ;
64097   arg2 = (Dali::Property::Index)jarg2;
64098
64099   Dali::Property::Index arg3 = 0 ;
64100   arg3 = (Dali::Property::Index)jarg3;
64101
64102   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
64103
64104   {
64105     try {
64106       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
64107     } catch (std::out_of_range& e) {
64108       {
64109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64110       };
64111     } catch (std::exception& e) {
64112       {
64113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64114       };
64115     } catch (...) {
64116       {
64117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64118       };
64119     }
64120   }
64121
64122
64123 }
64124
64125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64126   void * jresult ;
64127   Dali::Toolkit::Control *arg1 = 0 ;
64128   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
64129
64130   arg1 = (Dali::Toolkit::Control *)jarg1;
64131   if (!arg1) {
64132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64133     return 0;
64134   }
64135   {
64136     try {
64137       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
64138     } catch (std::out_of_range& e) {
64139       {
64140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64141       };
64142     } catch (std::exception& e) {
64143       {
64144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64145       };
64146     } catch (Dali::DaliException e) {
64147       {
64148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64149       };
64150     } catch (...) {
64151       {
64152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64153       };
64154     }
64155   }
64156
64157   jresult = (void *)result;
64158   return jresult;
64159 }
64160
64161
64162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64163   unsigned int jresult ;
64164   Dali::Toolkit::Control *arg1 = 0 ;
64165   bool result;
64166
64167   arg1 = (Dali::Toolkit::Control *)jarg1;
64168   if (!arg1) {
64169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64170     return 0;
64171   }
64172   {
64173     try {
64174       result = (bool)arg1->IsResourceReady();
64175     } catch (std::out_of_range& e) {
64176       {
64177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64178       };
64179     } catch (std::exception& e) {
64180       {
64181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64182       };
64183     } catch (Dali::DaliException e) {
64184       {
64185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64186       };
64187     } catch (...) {
64188       {
64189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64190       };
64191     }
64192   }
64193
64194   jresult = result;
64195   return jresult;
64196 }
64197
64198
64199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64200   void * jresult ;
64201   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64202
64203   {
64204     try {
64205       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64206     } catch (std::out_of_range& e) {
64207       {
64208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64209       };
64210     } catch (std::exception& e) {
64211       {
64212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (Dali::DaliException e) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64217       };
64218     } catch (...) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64221       };
64222     }
64223   }
64224
64225   jresult = (void *)result;
64226   return jresult;
64227 }
64228
64229
64230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64231   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64232
64233   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64234   {
64235     try {
64236       delete arg1;
64237     } catch (std::out_of_range& e) {
64238       {
64239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64240       };
64241     } catch (std::exception& e) {
64242       {
64243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64244       };
64245     } catch (Dali::DaliException e) {
64246       {
64247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64248       };
64249     } catch (...) {
64250       {
64251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64252       };
64253     }
64254   }
64255
64256 }
64257
64258
64259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64260   void * jresult ;
64261   Dali::Toolkit::KeyInputFocusManager result;
64262
64263   {
64264     try {
64265       result = Dali::Toolkit::KeyInputFocusManager::Get();
64266     } catch (std::out_of_range& e) {
64267       {
64268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64269       };
64270     } catch (std::exception& e) {
64271       {
64272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64273       };
64274     } catch (Dali::DaliException e) {
64275       {
64276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64277       };
64278     } catch (...) {
64279       {
64280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64281       };
64282     }
64283   }
64284
64285   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64286   return jresult;
64287 }
64288
64289
64290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64291   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64292   Dali::Toolkit::Control arg2 ;
64293   Dali::Toolkit::Control *argp2 ;
64294
64295   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64296   argp2 = (Dali::Toolkit::Control *)jarg2;
64297   if (!argp2) {
64298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64299     return ;
64300   }
64301   arg2 = *argp2;
64302   {
64303     try {
64304       (arg1)->SetFocus(arg2);
64305     } catch (std::out_of_range& e) {
64306       {
64307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (std::exception& e) {
64310       {
64311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64312       };
64313     } catch (Dali::DaliException e) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64316       };
64317     } catch (...) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64320       };
64321     }
64322   }
64323
64324 }
64325
64326
64327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64328   void * jresult ;
64329   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64330   Dali::Toolkit::Control result;
64331
64332   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64333   {
64334     try {
64335       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64336     } catch (std::out_of_range& e) {
64337       {
64338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64339       };
64340     } catch (std::exception& e) {
64341       {
64342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64343       };
64344     } catch (Dali::DaliException e) {
64345       {
64346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64347       };
64348     } catch (...) {
64349       {
64350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64351       };
64352     }
64353   }
64354
64355   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64356   return jresult;
64357 }
64358
64359
64360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64361   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64362   Dali::Toolkit::Control arg2 ;
64363   Dali::Toolkit::Control *argp2 ;
64364
64365   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64366   argp2 = (Dali::Toolkit::Control *)jarg2;
64367   if (!argp2) {
64368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64369     return ;
64370   }
64371   arg2 = *argp2;
64372   {
64373     try {
64374       (arg1)->RemoveFocus(arg2);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64382       };
64383     } catch (Dali::DaliException e) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64386       };
64387     } catch (...) {
64388       {
64389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64390       };
64391     }
64392   }
64393
64394 }
64395
64396
64397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64398   void * jresult ;
64399   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64400   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64401
64402   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64403   {
64404     try {
64405       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64406     } catch (std::out_of_range& e) {
64407       {
64408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64409       };
64410     } catch (std::exception& e) {
64411       {
64412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64413       };
64414     } catch (Dali::DaliException e) {
64415       {
64416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64417       };
64418     } catch (...) {
64419       {
64420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64421       };
64422     }
64423   }
64424
64425   jresult = (void *)result;
64426   return jresult;
64427 }
64428
64429
64430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64431   void * jresult ;
64432   Dali::Toolkit::Alignment::Padding *result = 0 ;
64433
64434   {
64435     try {
64436       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64437     } catch (std::out_of_range& e) {
64438       {
64439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64440       };
64441     } catch (std::exception& e) {
64442       {
64443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64444       };
64445     } catch (Dali::DaliException e) {
64446       {
64447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64448       };
64449     } catch (...) {
64450       {
64451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64452       };
64453     }
64454   }
64455
64456   jresult = (void *)result;
64457   return jresult;
64458 }
64459
64460
64461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64462   void * jresult ;
64463   float arg1 ;
64464   float arg2 ;
64465   float arg3 ;
64466   float arg4 ;
64467   Dali::Toolkit::Alignment::Padding *result = 0 ;
64468
64469   arg1 = (float)jarg1;
64470   arg2 = (float)jarg2;
64471   arg3 = (float)jarg3;
64472   arg4 = (float)jarg4;
64473   {
64474     try {
64475       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64476     } catch (std::out_of_range& e) {
64477       {
64478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64479       };
64480     } catch (std::exception& e) {
64481       {
64482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (Dali::DaliException e) {
64485       {
64486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64487       };
64488     } catch (...) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64491       };
64492     }
64493   }
64494
64495   jresult = (void *)result;
64496   return jresult;
64497 }
64498
64499
64500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64501   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64502   float arg2 ;
64503
64504   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64505   arg2 = (float)jarg2;
64506   if (arg1) (arg1)->left = arg2;
64507 }
64508
64509
64510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64511   float jresult ;
64512   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64513   float result;
64514
64515   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64516   result = (float) ((arg1)->left);
64517   jresult = result;
64518   return jresult;
64519 }
64520
64521
64522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64523   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64524   float arg2 ;
64525
64526   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64527   arg2 = (float)jarg2;
64528   if (arg1) (arg1)->right = arg2;
64529 }
64530
64531
64532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64533   float jresult ;
64534   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64535   float result;
64536
64537   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64538   result = (float) ((arg1)->right);
64539   jresult = result;
64540   return jresult;
64541 }
64542
64543
64544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64545   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64546   float arg2 ;
64547
64548   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64549   arg2 = (float)jarg2;
64550   if (arg1) (arg1)->top = arg2;
64551 }
64552
64553
64554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64555   float jresult ;
64556   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64557   float result;
64558
64559   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64560   result = (float) ((arg1)->top);
64561   jresult = result;
64562   return jresult;
64563 }
64564
64565
64566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64567   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64568   float arg2 ;
64569
64570   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64571   arg2 = (float)jarg2;
64572   if (arg1) (arg1)->bottom = arg2;
64573 }
64574
64575
64576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64577   float jresult ;
64578   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64579   float result;
64580
64581   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64582   result = (float) ((arg1)->bottom);
64583   jresult = result;
64584   return jresult;
64585 }
64586
64587
64588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64589   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64590
64591   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64592   {
64593     try {
64594       delete arg1;
64595     } catch (std::out_of_range& e) {
64596       {
64597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64598       };
64599     } catch (std::exception& e) {
64600       {
64601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64602       };
64603     } catch (Dali::DaliException e) {
64604       {
64605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64606       };
64607     } catch (...) {
64608       {
64609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64610       };
64611     }
64612   }
64613
64614 }
64615
64616
64617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64618   void * jresult ;
64619   Dali::Toolkit::Alignment *result = 0 ;
64620
64621   {
64622     try {
64623       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64624     } catch (std::out_of_range& e) {
64625       {
64626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64627       };
64628     } catch (std::exception& e) {
64629       {
64630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64631       };
64632     } catch (Dali::DaliException e) {
64633       {
64634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64635       };
64636     } catch (...) {
64637       {
64638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64639       };
64640     }
64641   }
64642
64643   jresult = (void *)result;
64644   return jresult;
64645 }
64646
64647
64648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64649   void * jresult ;
64650   Dali::Toolkit::Alignment::Type arg1 ;
64651   Dali::Toolkit::Alignment::Type arg2 ;
64652   Dali::Toolkit::Alignment result;
64653
64654   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64655   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64656   {
64657     try {
64658       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64659     } catch (std::out_of_range& e) {
64660       {
64661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64662       };
64663     } catch (std::exception& e) {
64664       {
64665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64666       };
64667     } catch (Dali::DaliException e) {
64668       {
64669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64670       };
64671     } catch (...) {
64672       {
64673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64674       };
64675     }
64676   }
64677
64678   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64679   return jresult;
64680 }
64681
64682
64683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64684   void * jresult ;
64685   Dali::Toolkit::Alignment::Type arg1 ;
64686   Dali::Toolkit::Alignment result;
64687
64688   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64689   {
64690     try {
64691       result = Dali::Toolkit::Alignment::New(arg1);
64692     } catch (std::out_of_range& e) {
64693       {
64694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64695       };
64696     } catch (std::exception& e) {
64697       {
64698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64699       };
64700     } catch (Dali::DaliException e) {
64701       {
64702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64703       };
64704     } catch (...) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64707       };
64708     }
64709   }
64710
64711   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64712   return jresult;
64713 }
64714
64715
64716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64717   void * jresult ;
64718   Dali::Toolkit::Alignment result;
64719
64720   {
64721     try {
64722       result = Dali::Toolkit::Alignment::New();
64723     } catch (std::out_of_range& e) {
64724       {
64725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64726       };
64727     } catch (std::exception& e) {
64728       {
64729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64730       };
64731     } catch (Dali::DaliException e) {
64732       {
64733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64734       };
64735     } catch (...) {
64736       {
64737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64738       };
64739     }
64740   }
64741
64742   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64743   return jresult;
64744 }
64745
64746
64747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64748   void * jresult ;
64749   Dali::Toolkit::Alignment *arg1 = 0 ;
64750   Dali::Toolkit::Alignment *result = 0 ;
64751
64752   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64753   if (!arg1) {
64754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64755     return 0;
64756   }
64757   {
64758     try {
64759       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64760     } catch (std::out_of_range& e) {
64761       {
64762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64763       };
64764     } catch (std::exception& e) {
64765       {
64766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64767       };
64768     } catch (Dali::DaliException e) {
64769       {
64770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64771       };
64772     } catch (...) {
64773       {
64774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64775       };
64776     }
64777   }
64778
64779   jresult = (void *)result;
64780   return jresult;
64781 }
64782
64783
64784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64785   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64786
64787   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64788   {
64789     try {
64790       delete arg1;
64791     } catch (std::out_of_range& e) {
64792       {
64793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64794       };
64795     } catch (std::exception& e) {
64796       {
64797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64798       };
64799     } catch (Dali::DaliException e) {
64800       {
64801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64802       };
64803     } catch (...) {
64804       {
64805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64806       };
64807     }
64808   }
64809
64810 }
64811
64812
64813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64814   void * jresult ;
64815   Dali::BaseHandle arg1 ;
64816   Dali::BaseHandle *argp1 ;
64817   Dali::Toolkit::Alignment result;
64818
64819   argp1 = (Dali::BaseHandle *)jarg1;
64820   if (!argp1) {
64821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64822     return 0;
64823   }
64824   arg1 = *argp1;
64825   {
64826     try {
64827       result = Dali::Toolkit::Alignment::DownCast(arg1);
64828     } catch (std::out_of_range& e) {
64829       {
64830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64831       };
64832     } catch (std::exception& e) {
64833       {
64834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64835       };
64836     } catch (Dali::DaliException e) {
64837       {
64838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64839       };
64840     } catch (...) {
64841       {
64842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64843       };
64844     }
64845   }
64846
64847   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64848   return jresult;
64849 }
64850
64851
64852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64853   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64854   Dali::Toolkit::Alignment::Type arg2 ;
64855
64856   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64857   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64858   {
64859     try {
64860       (arg1)->SetAlignmentType(arg2);
64861     } catch (std::out_of_range& e) {
64862       {
64863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64864       };
64865     } catch (std::exception& e) {
64866       {
64867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64868       };
64869     } catch (Dali::DaliException e) {
64870       {
64871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64872       };
64873     } catch (...) {
64874       {
64875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64876       };
64877     }
64878   }
64879
64880 }
64881
64882
64883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64884   int jresult ;
64885   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64886   Dali::Toolkit::Alignment::Type result;
64887
64888   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64889   {
64890     try {
64891       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64892     } catch (std::out_of_range& e) {
64893       {
64894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64895       };
64896     } catch (std::exception& e) {
64897       {
64898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64899       };
64900     } catch (Dali::DaliException e) {
64901       {
64902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64903       };
64904     } catch (...) {
64905       {
64906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64907       };
64908     }
64909   }
64910
64911   jresult = (int)result;
64912   return jresult;
64913 }
64914
64915
64916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64917   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64918   Dali::Toolkit::Alignment::Scaling arg2 ;
64919
64920   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64921   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64922   {
64923     try {
64924       (arg1)->SetScaling(arg2);
64925     } catch (std::out_of_range& e) {
64926       {
64927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64928       };
64929     } catch (std::exception& e) {
64930       {
64931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64932       };
64933     } catch (Dali::DaliException e) {
64934       {
64935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64936       };
64937     } catch (...) {
64938       {
64939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64940       };
64941     }
64942   }
64943
64944 }
64945
64946
64947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64948   int jresult ;
64949   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64950   Dali::Toolkit::Alignment::Scaling result;
64951
64952   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64953   {
64954     try {
64955       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64956     } catch (std::out_of_range& e) {
64957       {
64958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64959       };
64960     } catch (std::exception& e) {
64961       {
64962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (Dali::DaliException e) {
64965       {
64966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64967       };
64968     } catch (...) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64971       };
64972     }
64973   }
64974
64975   jresult = (int)result;
64976   return jresult;
64977 }
64978
64979
64980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64981   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64982   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64983
64984   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64985   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64986   if (!arg2) {
64987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64988     return ;
64989   }
64990   {
64991     try {
64992       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64993     } catch (std::out_of_range& e) {
64994       {
64995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64996       };
64997     } catch (std::exception& e) {
64998       {
64999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65000       };
65001     } catch (Dali::DaliException e) {
65002       {
65003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65004       };
65005     } catch (...) {
65006       {
65007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65008       };
65009     }
65010   }
65011
65012 }
65013
65014
65015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
65016   void * jresult ;
65017   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65018   Dali::Toolkit::Alignment::Padding *result = 0 ;
65019
65020   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65021   {
65022     try {
65023       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
65024     } catch (std::out_of_range& e) {
65025       {
65026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65027       };
65028     } catch (std::exception& e) {
65029       {
65030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65031       };
65032     } catch (Dali::DaliException e) {
65033       {
65034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65035       };
65036     } catch (...) {
65037       {
65038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65039       };
65040     }
65041   }
65042
65043   jresult = (void *)result;
65044   return jresult;
65045 }
65046
65047
65048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
65049   void * jresult ;
65050   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65051   Dali::Toolkit::Alignment *arg2 = 0 ;
65052   Dali::Toolkit::Alignment *result = 0 ;
65053
65054   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65055   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65056   if (!arg2) {
65057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65058     return 0;
65059   }
65060   {
65061     try {
65062       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65063     } catch (std::out_of_range& e) {
65064       {
65065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65066       };
65067     } catch (std::exception& e) {
65068       {
65069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65070       };
65071     } catch (Dali::DaliException e) {
65072       {
65073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65074       };
65075     } catch (...) {
65076       {
65077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65078       };
65079     }
65080   }
65081
65082   jresult = (void *)result;
65083   return jresult;
65084 }
65085
65086
65087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65088   int jresult ;
65089   int result;
65090
65091   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65092   jresult = (int)result;
65093   return jresult;
65094 }
65095
65096
65097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65098   int jresult ;
65099   int result;
65100
65101   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65102   jresult = (int)result;
65103   return jresult;
65104 }
65105
65106
65107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65108   int jresult ;
65109   int result;
65110
65111   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65112   jresult = (int)result;
65113   return jresult;
65114 }
65115
65116
65117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65118   int jresult ;
65119   int result;
65120
65121   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65122   jresult = (int)result;
65123   return jresult;
65124 }
65125
65126
65127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65128   int jresult ;
65129   int result;
65130
65131   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65132   jresult = (int)result;
65133   return jresult;
65134 }
65135
65136
65137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65138   int jresult ;
65139   int result;
65140
65141   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65142   jresult = (int)result;
65143   return jresult;
65144 }
65145
65146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65147   int jresult ;
65148   int result;
65149
65150   result = (int)Dali::Toolkit::Button::Property::LABEL;
65151   jresult = (int)result;
65152   return jresult;
65153 }
65154
65155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65156   void * jresult ;
65157   Dali::Toolkit::Button::Property *result = 0 ;
65158
65159   {
65160     try {
65161       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65162     } catch (std::out_of_range& e) {
65163       {
65164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65165       };
65166     } catch (std::exception& e) {
65167       {
65168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65169       };
65170     } catch (Dali::DaliException e) {
65171       {
65172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65173       };
65174     } catch (...) {
65175       {
65176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65177       };
65178     }
65179   }
65180
65181   jresult = (void *)result;
65182   return jresult;
65183 }
65184
65185
65186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65187   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65188
65189   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65190   {
65191     try {
65192       delete arg1;
65193     } catch (std::out_of_range& e) {
65194       {
65195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65196       };
65197     } catch (std::exception& e) {
65198       {
65199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65200       };
65201     } catch (Dali::DaliException e) {
65202       {
65203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65204       };
65205     } catch (...) {
65206       {
65207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65208       };
65209     }
65210   }
65211
65212 }
65213
65214
65215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65216   void * jresult ;
65217   Dali::Toolkit::Button *result = 0 ;
65218
65219   {
65220     try {
65221       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65222     } catch (std::out_of_range& e) {
65223       {
65224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65225       };
65226     } catch (std::exception& e) {
65227       {
65228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65229       };
65230     } catch (Dali::DaliException e) {
65231       {
65232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65233       };
65234     } catch (...) {
65235       {
65236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65237       };
65238     }
65239   }
65240
65241   jresult = (void *)result;
65242   return jresult;
65243 }
65244
65245
65246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65247   void * jresult ;
65248   Dali::Toolkit::Button *arg1 = 0 ;
65249   Dali::Toolkit::Button *result = 0 ;
65250
65251   arg1 = (Dali::Toolkit::Button *)jarg1;
65252   if (!arg1) {
65253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65254     return 0;
65255   }
65256   {
65257     try {
65258       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65259     } catch (std::out_of_range& e) {
65260       {
65261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65262       };
65263     } catch (std::exception& e) {
65264       {
65265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65266       };
65267     } catch (Dali::DaliException e) {
65268       {
65269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65270       };
65271     } catch (...) {
65272       {
65273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65274       };
65275     }
65276   }
65277
65278   jresult = (void *)result;
65279   return jresult;
65280 }
65281
65282
65283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65284   void * jresult ;
65285   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65286   Dali::Toolkit::Button *arg2 = 0 ;
65287   Dali::Toolkit::Button *result = 0 ;
65288
65289   arg1 = (Dali::Toolkit::Button *)jarg1;
65290   arg2 = (Dali::Toolkit::Button *)jarg2;
65291   if (!arg2) {
65292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65293     return 0;
65294   }
65295   {
65296     try {
65297       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65298     } catch (std::out_of_range& e) {
65299       {
65300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65301       };
65302     } catch (std::exception& e) {
65303       {
65304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65305       };
65306     } catch (Dali::DaliException e) {
65307       {
65308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65309       };
65310     } catch (...) {
65311       {
65312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65313       };
65314     }
65315   }
65316
65317   jresult = (void *)result;
65318   return jresult;
65319 }
65320
65321
65322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65323   void * jresult ;
65324   Dali::BaseHandle arg1 ;
65325   Dali::BaseHandle *argp1 ;
65326   Dali::Toolkit::Button result;
65327
65328   argp1 = (Dali::BaseHandle *)jarg1;
65329   if (!argp1) {
65330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65331     return 0;
65332   }
65333   arg1 = *argp1;
65334   {
65335     try {
65336       result = Dali::Toolkit::Button::DownCast(arg1);
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 (Dali::DaliException e) {
65346       {
65347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65348       };
65349     } catch (...) {
65350       {
65351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65352       };
65353     }
65354   }
65355
65356   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65357   return jresult;
65358 }
65359
65360
65361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65362   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65363
65364   arg1 = (Dali::Toolkit::Button *)jarg1;
65365   {
65366     try {
65367       delete arg1;
65368     } catch (std::out_of_range& e) {
65369       {
65370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65371       };
65372     } catch (std::exception& e) {
65373       {
65374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65375       };
65376     } catch (Dali::DaliException e) {
65377       {
65378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65379       };
65380     } catch (...) {
65381       {
65382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65383       };
65384     }
65385   }
65386
65387 }
65388
65389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65390   void * jresult ;
65391   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65392   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65393
65394   arg1 = (Dali::Toolkit::Button *)jarg1;
65395   {
65396     try {
65397       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65398     } catch (std::out_of_range& e) {
65399       {
65400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65401       };
65402     } catch (std::exception& e) {
65403       {
65404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65405       };
65406     } catch (Dali::DaliException e) {
65407       {
65408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65409       };
65410     } catch (...) {
65411       {
65412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65413       };
65414     }
65415   }
65416
65417   jresult = (void *)result;
65418   return jresult;
65419 }
65420
65421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65422   void * jresult ;
65423   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65424   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65425
65426   arg1 = (Dali::Toolkit::Button *)jarg1;
65427   {
65428     try {
65429       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65430     } catch (std::out_of_range& e) {
65431       {
65432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (std::exception& e) {
65435       {
65436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65437       };
65438     } catch (Dali::DaliException e) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65441       };
65442     } catch (...) {
65443       {
65444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65445       };
65446     }
65447   }
65448
65449   jresult = (void *)result;
65450   return jresult;
65451 }
65452
65453
65454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65455   void * jresult ;
65456   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65457   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65458
65459   arg1 = (Dali::Toolkit::Button *)jarg1;
65460   {
65461     try {
65462       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65463     } catch (std::out_of_range& e) {
65464       {
65465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65466       };
65467     } catch (std::exception& e) {
65468       {
65469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65470       };
65471     } catch (Dali::DaliException e) {
65472       {
65473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65474       };
65475     } catch (...) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65478       };
65479     }
65480   }
65481
65482   jresult = (void *)result;
65483   return jresult;
65484 }
65485
65486
65487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65488   void * jresult ;
65489   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65490   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65491
65492   arg1 = (Dali::Toolkit::Button *)jarg1;
65493   {
65494     try {
65495       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65496     } catch (std::out_of_range& e) {
65497       {
65498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65499       };
65500     } catch (std::exception& e) {
65501       {
65502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65503       };
65504     } catch (Dali::DaliException e) {
65505       {
65506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65511       };
65512     }
65513   }
65514
65515   jresult = (void *)result;
65516   return jresult;
65517 }
65518
65519
65520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65521   void * jresult ;
65522   Dali::Toolkit::CheckBoxButton *result = 0 ;
65523
65524   {
65525     try {
65526       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65527     } catch (std::out_of_range& e) {
65528       {
65529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65530       };
65531     } catch (std::exception& e) {
65532       {
65533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65534       };
65535     } catch (Dali::DaliException e) {
65536       {
65537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65538       };
65539     } catch (...) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65542       };
65543     }
65544   }
65545
65546   jresult = (void *)result;
65547   return jresult;
65548 }
65549
65550
65551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65552   void * jresult ;
65553   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65554   Dali::Toolkit::CheckBoxButton *result = 0 ;
65555
65556   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65557   if (!arg1) {
65558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65559     return 0;
65560   }
65561   {
65562     try {
65563       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65564     } catch (std::out_of_range& e) {
65565       {
65566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65567       };
65568     } catch (std::exception& e) {
65569       {
65570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65571       };
65572     } catch (Dali::DaliException e) {
65573       {
65574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65575       };
65576     } catch (...) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65579       };
65580     }
65581   }
65582
65583   jresult = (void *)result;
65584   return jresult;
65585 }
65586
65587
65588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65589   void * jresult ;
65590   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65591   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65592   Dali::Toolkit::CheckBoxButton *result = 0 ;
65593
65594   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65595   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65596   if (!arg2) {
65597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65598     return 0;
65599   }
65600   {
65601     try {
65602       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65603     } catch (std::out_of_range& e) {
65604       {
65605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65606       };
65607     } catch (std::exception& e) {
65608       {
65609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65610       };
65611     } catch (Dali::DaliException e) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65614       };
65615     } catch (...) {
65616       {
65617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65618       };
65619     }
65620   }
65621
65622   jresult = (void *)result;
65623   return jresult;
65624 }
65625
65626
65627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65628   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65629
65630   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65631   {
65632     try {
65633       delete arg1;
65634     } catch (std::out_of_range& e) {
65635       {
65636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65637       };
65638     } catch (std::exception& e) {
65639       {
65640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65641       };
65642     } catch (Dali::DaliException e) {
65643       {
65644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65645       };
65646     } catch (...) {
65647       {
65648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65649       };
65650     }
65651   }
65652
65653 }
65654
65655
65656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65657   void * jresult ;
65658   Dali::Toolkit::CheckBoxButton result;
65659
65660   {
65661     try {
65662       result = Dali::Toolkit::CheckBoxButton::New();
65663     } catch (std::out_of_range& e) {
65664       {
65665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (std::exception& e) {
65668       {
65669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65670       };
65671     } catch (Dali::DaliException e) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65674       };
65675     } catch (...) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65678       };
65679     }
65680   }
65681
65682   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65683   return jresult;
65684 }
65685
65686
65687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65688   void * jresult ;
65689   Dali::BaseHandle arg1 ;
65690   Dali::BaseHandle *argp1 ;
65691   Dali::Toolkit::CheckBoxButton result;
65692
65693   argp1 = (Dali::BaseHandle *)jarg1;
65694   if (!argp1) {
65695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65696     return 0;
65697   }
65698   arg1 = *argp1;
65699   {
65700     try {
65701       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (Dali::DaliException e) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65713       };
65714     } catch (...) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65717       };
65718     }
65719   }
65720
65721   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65722   return jresult;
65723 }
65724
65725
65726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65727   int jresult ;
65728   int result;
65729
65730   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65731   jresult = (int)result;
65732   return jresult;
65733 }
65734
65735
65736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65737   int jresult ;
65738   int result;
65739
65740   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65741   jresult = (int)result;
65742   return jresult;
65743 }
65744
65745
65746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65747   void * jresult ;
65748   Dali::Toolkit::PushButton::Property *result = 0 ;
65749
65750   {
65751     try {
65752       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65753     } catch (std::out_of_range& e) {
65754       {
65755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65756       };
65757     } catch (std::exception& e) {
65758       {
65759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65760       };
65761     } catch (Dali::DaliException e) {
65762       {
65763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65764       };
65765     } catch (...) {
65766       {
65767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65768       };
65769     }
65770   }
65771
65772   jresult = (void *)result;
65773   return jresult;
65774 }
65775
65776
65777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65778   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65779
65780   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65781   {
65782     try {
65783       delete arg1;
65784     } catch (std::out_of_range& e) {
65785       {
65786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65787       };
65788     } catch (std::exception& e) {
65789       {
65790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65791       };
65792     } catch (Dali::DaliException e) {
65793       {
65794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65795       };
65796     } catch (...) {
65797       {
65798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65799       };
65800     }
65801   }
65802
65803 }
65804
65805
65806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65807   void * jresult ;
65808   Dali::Toolkit::PushButton *result = 0 ;
65809
65810   {
65811     try {
65812       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65813     } catch (std::out_of_range& e) {
65814       {
65815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65816       };
65817     } catch (std::exception& e) {
65818       {
65819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65820       };
65821     } catch (Dali::DaliException e) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65824       };
65825     } catch (...) {
65826       {
65827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65828       };
65829     }
65830   }
65831
65832   jresult = (void *)result;
65833   return jresult;
65834 }
65835
65836
65837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65838   void * jresult ;
65839   Dali::Toolkit::PushButton *arg1 = 0 ;
65840   Dali::Toolkit::PushButton *result = 0 ;
65841
65842   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65843   if (!arg1) {
65844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65845     return 0;
65846   }
65847   {
65848     try {
65849       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65850     } catch (std::out_of_range& e) {
65851       {
65852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65853       };
65854     } catch (std::exception& e) {
65855       {
65856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65857       };
65858     } catch (Dali::DaliException e) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65861       };
65862     } catch (...) {
65863       {
65864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65865       };
65866     }
65867   }
65868
65869   jresult = (void *)result;
65870   return jresult;
65871 }
65872
65873
65874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65875   void * jresult ;
65876   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65877   Dali::Toolkit::PushButton *arg2 = 0 ;
65878   Dali::Toolkit::PushButton *result = 0 ;
65879
65880   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65881   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65882   if (!arg2) {
65883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65884     return 0;
65885   }
65886   {
65887     try {
65888       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65889     } catch (std::out_of_range& e) {
65890       {
65891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65892       };
65893     } catch (std::exception& e) {
65894       {
65895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65896       };
65897     } catch (Dali::DaliException e) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65900       };
65901     } catch (...) {
65902       {
65903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65904       };
65905     }
65906   }
65907
65908   jresult = (void *)result;
65909   return jresult;
65910 }
65911
65912
65913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65914   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65915
65916   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65917   {
65918     try {
65919       delete arg1;
65920     } catch (std::out_of_range& e) {
65921       {
65922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65923       };
65924     } catch (std::exception& e) {
65925       {
65926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65927       };
65928     } catch (Dali::DaliException e) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65931       };
65932     } catch (...) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65935       };
65936     }
65937   }
65938
65939 }
65940
65941
65942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65943   void * jresult ;
65944   Dali::Toolkit::PushButton result;
65945
65946   {
65947     try {
65948       result = Dali::Toolkit::PushButton::New();
65949     } catch (std::out_of_range& e) {
65950       {
65951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65952       };
65953     } catch (std::exception& e) {
65954       {
65955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65956       };
65957     } catch (Dali::DaliException e) {
65958       {
65959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65960       };
65961     } catch (...) {
65962       {
65963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65964       };
65965     }
65966   }
65967
65968   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65969   return jresult;
65970 }
65971
65972
65973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65974   void * jresult ;
65975   Dali::BaseHandle arg1 ;
65976   Dali::BaseHandle *argp1 ;
65977   Dali::Toolkit::PushButton result;
65978
65979   argp1 = (Dali::BaseHandle *)jarg1;
65980   if (!argp1) {
65981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65982     return 0;
65983   }
65984   arg1 = *argp1;
65985   {
65986     try {
65987       result = Dali::Toolkit::PushButton::DownCast(arg1);
65988     } catch (std::out_of_range& e) {
65989       {
65990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65991       };
65992     } catch (std::exception& e) {
65993       {
65994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65995       };
65996     } catch (Dali::DaliException e) {
65997       {
65998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65999       };
66000     } catch (...) {
66001       {
66002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66003       };
66004     }
66005   }
66006
66007   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66008   return jresult;
66009 }
66010
66011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66012   void * jresult ;
66013   Dali::Toolkit::RadioButton *result = 0 ;
66014
66015   {
66016     try {
66017       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66018     } catch (std::out_of_range& e) {
66019       {
66020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66021       };
66022     } catch (std::exception& e) {
66023       {
66024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66025       };
66026     } catch (Dali::DaliException e) {
66027       {
66028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66029       };
66030     } catch (...) {
66031       {
66032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66033       };
66034     }
66035   }
66036
66037   jresult = (void *)result;
66038   return jresult;
66039 }
66040
66041
66042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66043   void * jresult ;
66044   Dali::Toolkit::RadioButton *arg1 = 0 ;
66045   Dali::Toolkit::RadioButton *result = 0 ;
66046
66047   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66048   if (!arg1) {
66049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66050     return 0;
66051   }
66052   {
66053     try {
66054       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66055     } catch (std::out_of_range& e) {
66056       {
66057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66058       };
66059     } catch (std::exception& e) {
66060       {
66061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (Dali::DaliException e) {
66064       {
66065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66066       };
66067     } catch (...) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66070       };
66071     }
66072   }
66073
66074   jresult = (void *)result;
66075   return jresult;
66076 }
66077
66078
66079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66080   void * jresult ;
66081   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66082   Dali::Toolkit::RadioButton *arg2 = 0 ;
66083   Dali::Toolkit::RadioButton *result = 0 ;
66084
66085   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66086   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66087   if (!arg2) {
66088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66089     return 0;
66090   }
66091   {
66092     try {
66093       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66094     } catch (std::out_of_range& e) {
66095       {
66096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66097       };
66098     } catch (std::exception& e) {
66099       {
66100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66101       };
66102     } catch (Dali::DaliException e) {
66103       {
66104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66105       };
66106     } catch (...) {
66107       {
66108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66109       };
66110     }
66111   }
66112
66113   jresult = (void *)result;
66114   return jresult;
66115 }
66116
66117
66118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66119   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66120
66121   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66122   {
66123     try {
66124       delete arg1;
66125     } catch (std::out_of_range& e) {
66126       {
66127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66128       };
66129     } catch (std::exception& e) {
66130       {
66131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66132       };
66133     } catch (Dali::DaliException e) {
66134       {
66135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66140       };
66141     }
66142   }
66143
66144 }
66145
66146
66147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66148   void * jresult ;
66149   Dali::Toolkit::RadioButton result;
66150
66151   {
66152     try {
66153       result = Dali::Toolkit::RadioButton::New();
66154     } catch (std::out_of_range& e) {
66155       {
66156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66157       };
66158     } catch (std::exception& e) {
66159       {
66160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66161       };
66162     } catch (Dali::DaliException e) {
66163       {
66164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66165       };
66166     } catch (...) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66169       };
66170     }
66171   }
66172
66173   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66174   return jresult;
66175 }
66176
66177
66178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66179   void * jresult ;
66180   std::string *arg1 = 0 ;
66181   Dali::Toolkit::RadioButton result;
66182
66183   if (!jarg1) {
66184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66185     return 0;
66186   }
66187   std::string arg1_str(jarg1);
66188   arg1 = &arg1_str;
66189   {
66190     try {
66191       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66192     } catch (std::out_of_range& e) {
66193       {
66194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66195       };
66196     } catch (std::exception& e) {
66197       {
66198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66199       };
66200     } catch (Dali::DaliException e) {
66201       {
66202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66203       };
66204     } catch (...) {
66205       {
66206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66207       };
66208     }
66209   }
66210
66211   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66212
66213   //argout typemap for const std::string&
66214
66215   return jresult;
66216 }
66217
66218
66219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66220   void * jresult ;
66221   Dali::BaseHandle arg1 ;
66222   Dali::BaseHandle *argp1 ;
66223   Dali::Toolkit::RadioButton result;
66224
66225   argp1 = (Dali::BaseHandle *)jarg1;
66226   if (!argp1) {
66227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66228     return 0;
66229   }
66230   arg1 = *argp1;
66231   {
66232     try {
66233       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66234     } catch (std::out_of_range& e) {
66235       {
66236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (std::exception& e) {
66239       {
66240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (Dali::DaliException e) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66249       };
66250     }
66251   }
66252
66253   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66254   return jresult;
66255 }
66256
66257
66258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66259   int jresult ;
66260   int result;
66261
66262   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66263   jresult = (int)result;
66264   return jresult;
66265 }
66266
66267
66268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66269   int jresult ;
66270   int result;
66271
66272   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66273   jresult = (int)result;
66274   return jresult;
66275 }
66276
66277
66278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66279   int jresult ;
66280   int result;
66281
66282   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66283   jresult = (int)result;
66284   return jresult;
66285 }
66286
66287
66288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66289   int jresult ;
66290   int result;
66291
66292   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66293   jresult = (int)result;
66294   return jresult;
66295 }
66296
66297
66298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66299   int jresult ;
66300   int result;
66301
66302   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66303   jresult = (int)result;
66304   return jresult;
66305 }
66306
66307
66308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66309   int jresult ;
66310   int result;
66311
66312   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66313   jresult = (int)result;
66314   return jresult;
66315 }
66316
66317
66318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66319   void * jresult ;
66320   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66321
66322   {
66323     try {
66324       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66325     } catch (std::out_of_range& e) {
66326       {
66327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66328       };
66329     } catch (std::exception& e) {
66330       {
66331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (Dali::DaliException e) {
66334       {
66335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66340       };
66341     }
66342   }
66343
66344   jresult = (void *)result;
66345   return jresult;
66346 }
66347
66348
66349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66350   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66351
66352   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66353   {
66354     try {
66355       delete arg1;
66356     } catch (std::out_of_range& e) {
66357       {
66358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66359       };
66360     } catch (std::exception& e) {
66361       {
66362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66363       };
66364     } catch (Dali::DaliException e) {
66365       {
66366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66367       };
66368     } catch (...) {
66369       {
66370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66371       };
66372     }
66373   }
66374
66375 }
66376
66377
66378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66379   int jresult ;
66380   int result;
66381
66382   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66383   jresult = (int)result;
66384   return jresult;
66385 }
66386
66387
66388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66389   int jresult ;
66390   int result;
66391
66392   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66393   jresult = (int)result;
66394   return jresult;
66395 }
66396
66397
66398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66399   int jresult ;
66400   int result;
66401
66402   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66403   jresult = (int)result;
66404   return jresult;
66405 }
66406
66407
66408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66409   void * jresult ;
66410   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66411
66412   {
66413     try {
66414       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66415     } catch (std::out_of_range& e) {
66416       {
66417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66418       };
66419     } catch (std::exception& e) {
66420       {
66421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66422       };
66423     } catch (Dali::DaliException e) {
66424       {
66425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66426       };
66427     } catch (...) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66430       };
66431     }
66432   }
66433
66434   jresult = (void *)result;
66435   return jresult;
66436 }
66437
66438
66439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66440   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66441
66442   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66443   {
66444     try {
66445       delete arg1;
66446     } catch (std::out_of_range& e) {
66447       {
66448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66449       };
66450     } catch (std::exception& e) {
66451       {
66452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66453       };
66454     } catch (Dali::DaliException e) {
66455       {
66456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66457       };
66458     } catch (...) {
66459       {
66460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66461       };
66462     }
66463   }
66464
66465 }
66466
66467
66468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66469   void * jresult ;
66470   Dali::Toolkit::FlexContainer *result = 0 ;
66471
66472   {
66473     try {
66474       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66475     } catch (std::out_of_range& e) {
66476       {
66477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66478       };
66479     } catch (std::exception& e) {
66480       {
66481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66482       };
66483     } catch (Dali::DaliException e) {
66484       {
66485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66486       };
66487     } catch (...) {
66488       {
66489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66490       };
66491     }
66492   }
66493
66494   jresult = (void *)result;
66495   return jresult;
66496 }
66497
66498
66499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66500   void * jresult ;
66501   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66502   Dali::Toolkit::FlexContainer *result = 0 ;
66503
66504   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66505   if (!arg1) {
66506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66507     return 0;
66508   }
66509   {
66510     try {
66511       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66512     } catch (std::out_of_range& e) {
66513       {
66514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66515       };
66516     } catch (std::exception& e) {
66517       {
66518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66519       };
66520     } catch (Dali::DaliException e) {
66521       {
66522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66523       };
66524     } catch (...) {
66525       {
66526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66527       };
66528     }
66529   }
66530
66531   jresult = (void *)result;
66532   return jresult;
66533 }
66534
66535
66536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66537   void * jresult ;
66538   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66539   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66540   Dali::Toolkit::FlexContainer *result = 0 ;
66541
66542   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66543   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66544   if (!arg2) {
66545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66546     return 0;
66547   }
66548   {
66549     try {
66550       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66551     } catch (std::out_of_range& e) {
66552       {
66553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66554       };
66555     } catch (std::exception& e) {
66556       {
66557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66558       };
66559     } catch (Dali::DaliException e) {
66560       {
66561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66562       };
66563     } catch (...) {
66564       {
66565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66566       };
66567     }
66568   }
66569
66570   jresult = (void *)result;
66571   return jresult;
66572 }
66573
66574
66575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66576   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66577
66578   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66579   {
66580     try {
66581       delete arg1;
66582     } catch (std::out_of_range& e) {
66583       {
66584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66585       };
66586     } catch (std::exception& e) {
66587       {
66588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66589       };
66590     } catch (Dali::DaliException e) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66593       };
66594     } catch (...) {
66595       {
66596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66597       };
66598     }
66599   }
66600
66601 }
66602
66603
66604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66605   void * jresult ;
66606   Dali::Toolkit::FlexContainer result;
66607
66608   {
66609     try {
66610       result = Dali::Toolkit::FlexContainer::New();
66611     } catch (std::out_of_range& e) {
66612       {
66613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66614       };
66615     } catch (std::exception& e) {
66616       {
66617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66618       };
66619     } catch (Dali::DaliException e) {
66620       {
66621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66622       };
66623     } catch (...) {
66624       {
66625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66626       };
66627     }
66628   }
66629
66630   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66631   return jresult;
66632 }
66633
66634
66635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66636   void * jresult ;
66637   Dali::BaseHandle arg1 ;
66638   Dali::BaseHandle *argp1 ;
66639   Dali::Toolkit::FlexContainer result;
66640
66641   argp1 = (Dali::BaseHandle *)jarg1;
66642   if (!argp1) {
66643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66644     return 0;
66645   }
66646   arg1 = *argp1;
66647   {
66648     try {
66649       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66650     } catch (std::out_of_range& e) {
66651       {
66652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66653       };
66654     } catch (std::exception& e) {
66655       {
66656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66657       };
66658     } catch (Dali::DaliException e) {
66659       {
66660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66661       };
66662     } catch (...) {
66663       {
66664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66665       };
66666     }
66667   }
66668
66669   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66670   return jresult;
66671 }
66672
66673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66674   int jresult ;
66675   int result;
66676
66677   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66678   jresult = (int)result;
66679   return jresult;
66680 }
66681
66682
66683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66684   int jresult ;
66685   int result;
66686
66687   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66688   jresult = (int)result;
66689   return jresult;
66690 }
66691
66692
66693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66694   int jresult ;
66695   int result;
66696
66697   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66698   jresult = (int)result;
66699   return jresult;
66700 }
66701
66702
66703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66704   void * jresult ;
66705   Dali::Toolkit::ImageView::Property *result = 0 ;
66706
66707   {
66708     try {
66709       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66710     } catch (std::out_of_range& e) {
66711       {
66712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66713       };
66714     } catch (std::exception& e) {
66715       {
66716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (Dali::DaliException e) {
66719       {
66720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66721       };
66722     } catch (...) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66725       };
66726     }
66727   }
66728
66729   jresult = (void *)result;
66730   return jresult;
66731 }
66732
66733
66734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66735   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66736
66737   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66738   {
66739     try {
66740       delete arg1;
66741     } catch (std::out_of_range& e) {
66742       {
66743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66744       };
66745     } catch (std::exception& e) {
66746       {
66747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66748       };
66749     } catch (Dali::DaliException e) {
66750       {
66751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66752       };
66753     } catch (...) {
66754       {
66755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66756       };
66757     }
66758   }
66759
66760 }
66761
66762
66763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66764   void * jresult ;
66765   Dali::Toolkit::ImageView *result = 0 ;
66766
66767   {
66768     try {
66769       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66770     } catch (std::out_of_range& e) {
66771       {
66772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66773       };
66774     } catch (std::exception& e) {
66775       {
66776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66777       };
66778     } catch (Dali::DaliException e) {
66779       {
66780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66781       };
66782     } catch (...) {
66783       {
66784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66785       };
66786     }
66787   }
66788
66789   jresult = (void *)result;
66790   return jresult;
66791 }
66792
66793
66794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66795   void * jresult ;
66796   Dali::Toolkit::ImageView result;
66797
66798   {
66799     try {
66800       result = Dali::Toolkit::ImageView::New();
66801     } catch (std::out_of_range& e) {
66802       {
66803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66804       };
66805     } catch (std::exception& e) {
66806       {
66807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66808       };
66809     } catch (Dali::DaliException e) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66812       };
66813     } catch (...) {
66814       {
66815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66816       };
66817     }
66818   }
66819
66820   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66821   return jresult;
66822 }
66823
66824
66825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66826   void * jresult ;
66827   std::string *arg1 = 0 ;
66828   Dali::Toolkit::ImageView result;
66829
66830   if (!jarg1) {
66831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66832     return 0;
66833   }
66834   std::string arg1_str(jarg1);
66835   arg1 = &arg1_str;
66836   {
66837     try {
66838       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66839     } catch (std::out_of_range& e) {
66840       {
66841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66842       };
66843     } catch (std::exception& e) {
66844       {
66845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66846       };
66847     } catch (Dali::DaliException e) {
66848       {
66849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66850       };
66851     } catch (...) {
66852       {
66853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66854       };
66855     }
66856   }
66857
66858   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66859
66860   //argout typemap for const std::string&
66861
66862   return jresult;
66863 }
66864
66865
66866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66867   void * jresult ;
66868   std::string *arg1 = 0 ;
66869   Dali::ImageDimensions arg2 ;
66870   Dali::ImageDimensions *argp2 ;
66871   Dali::Toolkit::ImageView result;
66872
66873   if (!jarg1) {
66874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66875     return 0;
66876   }
66877   std::string arg1_str(jarg1);
66878   arg1 = &arg1_str;
66879   argp2 = (Dali::ImageDimensions *)jarg2;
66880   if (!argp2) {
66881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66882     return 0;
66883   }
66884   arg2 = *argp2;
66885   {
66886     try {
66887       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66888     } catch (std::out_of_range& e) {
66889       {
66890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66891       };
66892     } catch (std::exception& e) {
66893       {
66894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66895       };
66896     } catch (Dali::DaliException e) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66899       };
66900     } catch (...) {
66901       {
66902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66903       };
66904     }
66905   }
66906
66907   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66908
66909   //argout typemap for const std::string&
66910
66911   return jresult;
66912 }
66913
66914
66915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66916   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66917
66918   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66919   {
66920     try {
66921       delete arg1;
66922     } catch (std::out_of_range& e) {
66923       {
66924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66925       };
66926     } catch (std::exception& e) {
66927       {
66928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66929       };
66930     } catch (Dali::DaliException e) {
66931       {
66932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66933       };
66934     } catch (...) {
66935       {
66936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66937       };
66938     }
66939   }
66940
66941 }
66942
66943
66944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66945   void * jresult ;
66946   Dali::Toolkit::ImageView *arg1 = 0 ;
66947   Dali::Toolkit::ImageView *result = 0 ;
66948
66949   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66950   if (!arg1) {
66951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66952     return 0;
66953   }
66954   {
66955     try {
66956       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66957     } catch (std::out_of_range& e) {
66958       {
66959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66960       };
66961     } catch (std::exception& e) {
66962       {
66963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66964       };
66965     } catch (Dali::DaliException e) {
66966       {
66967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66968       };
66969     } catch (...) {
66970       {
66971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66972       };
66973     }
66974   }
66975
66976   jresult = (void *)result;
66977   return jresult;
66978 }
66979
66980
66981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66982   void * jresult ;
66983   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66984   Dali::Toolkit::ImageView *arg2 = 0 ;
66985   Dali::Toolkit::ImageView *result = 0 ;
66986
66987   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66988   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66989   if (!arg2) {
66990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66991     return 0;
66992   }
66993   {
66994     try {
66995       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66996     } catch (std::out_of_range& e) {
66997       {
66998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66999       };
67000     } catch (std::exception& e) {
67001       {
67002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67003       };
67004     } catch (Dali::DaliException e) {
67005       {
67006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67007       };
67008     } catch (...) {
67009       {
67010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67011       };
67012     }
67013   }
67014
67015   jresult = (void *)result;
67016   return jresult;
67017 }
67018
67019
67020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67021   void * jresult ;
67022   Dali::BaseHandle arg1 ;
67023   Dali::BaseHandle *argp1 ;
67024   Dali::Toolkit::ImageView result;
67025
67026   argp1 = (Dali::BaseHandle *)jarg1;
67027   if (!argp1) {
67028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67029     return 0;
67030   }
67031   arg1 = *argp1;
67032   {
67033     try {
67034       result = Dali::Toolkit::ImageView::DownCast(arg1);
67035     } catch (std::out_of_range& e) {
67036       {
67037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67038       };
67039     } catch (std::exception& e) {
67040       {
67041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67042       };
67043     } catch (Dali::DaliException e) {
67044       {
67045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67046       };
67047     } catch (...) {
67048       {
67049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67050       };
67051     }
67052   }
67053
67054   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67055   return jresult;
67056 }
67057
67058
67059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67060   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67061   std::string *arg2 = 0 ;
67062
67063   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67064   if (!jarg2) {
67065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67066     return ;
67067   }
67068   std::string arg2_str(jarg2);
67069   arg2 = &arg2_str;
67070   {
67071     try {
67072       (arg1)->SetImage((std::string const &)*arg2);
67073     } catch (std::out_of_range& e) {
67074       {
67075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67076       };
67077     } catch (std::exception& e) {
67078       {
67079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67080       };
67081     } catch (Dali::DaliException e) {
67082       {
67083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67084       };
67085     } catch (...) {
67086       {
67087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67088       };
67089     }
67090   }
67091
67092
67093   //argout typemap for const std::string&
67094
67095 }
67096
67097
67098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67099   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67100   std::string *arg2 = 0 ;
67101   Dali::ImageDimensions arg3 ;
67102   Dali::ImageDimensions *argp3 ;
67103
67104   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67105   if (!jarg2) {
67106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67107     return ;
67108   }
67109   std::string arg2_str(jarg2);
67110   arg2 = &arg2_str;
67111   argp3 = (Dali::ImageDimensions *)jarg3;
67112   if (!argp3) {
67113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67114     return ;
67115   }
67116   arg3 = *argp3;
67117   {
67118     try {
67119       (arg1)->SetImage((std::string const &)*arg2,arg3);
67120     } catch (std::out_of_range& e) {
67121       {
67122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67123       };
67124     } catch (std::exception& e) {
67125       {
67126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67127       };
67128     } catch (Dali::DaliException e) {
67129       {
67130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67131       };
67132     } catch (...) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67135       };
67136     }
67137   }
67138
67139
67140   //argout typemap for const std::string&
67141
67142 }
67143
67144
67145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67146   int jresult ;
67147   int result;
67148
67149   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67150   jresult = (int)result;
67151   return jresult;
67152 }
67153
67154
67155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67156   int jresult ;
67157   int result;
67158
67159   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67160   jresult = (int)result;
67161   return jresult;
67162 }
67163
67164
67165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67166   int jresult ;
67167   int result;
67168
67169   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67170   jresult = (int)result;
67171   return jresult;
67172 }
67173
67174
67175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67176   int jresult ;
67177   int result;
67178
67179   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67180   jresult = (int)result;
67181   return jresult;
67182 }
67183
67184
67185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67186   int jresult ;
67187   int result;
67188
67189   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67190   jresult = (int)result;
67191   return jresult;
67192 }
67193
67194
67195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67196   int jresult ;
67197   int result;
67198
67199   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67200   jresult = (int)result;
67201   return jresult;
67202 }
67203
67204
67205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67206   int jresult ;
67207   int result;
67208
67209   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67210   jresult = (int)result;
67211   return jresult;
67212 }
67213
67214
67215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67216   int jresult ;
67217   int result;
67218
67219   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67220   jresult = (int)result;
67221   return jresult;
67222 }
67223
67224
67225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67226   void * jresult ;
67227   Dali::Toolkit::Model3dView::Property *result = 0 ;
67228
67229   {
67230     try {
67231       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67232     } catch (std::out_of_range& e) {
67233       {
67234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (std::exception& e) {
67237       {
67238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67239       };
67240     } catch (Dali::DaliException e) {
67241       {
67242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67243       };
67244     } catch (...) {
67245       {
67246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67247       };
67248     }
67249   }
67250
67251   jresult = (void *)result;
67252   return jresult;
67253 }
67254
67255
67256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67257   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67258
67259   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67260   {
67261     try {
67262       delete arg1;
67263     } catch (std::out_of_range& e) {
67264       {
67265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67266       };
67267     } catch (std::exception& e) {
67268       {
67269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67270       };
67271     } catch (Dali::DaliException e) {
67272       {
67273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67274       };
67275     } catch (...) {
67276       {
67277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67278       };
67279     }
67280   }
67281
67282 }
67283
67284
67285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67286   void * jresult ;
67287   Dali::Toolkit::Model3dView result;
67288
67289   {
67290     try {
67291       result = Dali::Toolkit::Model3dView::New();
67292     } catch (std::out_of_range& e) {
67293       {
67294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67295       };
67296     } catch (std::exception& e) {
67297       {
67298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67299       };
67300     } catch (Dali::DaliException e) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67303       };
67304     } catch (...) {
67305       {
67306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67307       };
67308     }
67309   }
67310
67311   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67312   return jresult;
67313 }
67314
67315
67316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67317   void * jresult ;
67318   std::string *arg1 = 0 ;
67319   std::string *arg2 = 0 ;
67320   std::string *arg3 = 0 ;
67321   Dali::Toolkit::Model3dView result;
67322
67323   if (!jarg1) {
67324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67325     return 0;
67326   }
67327   std::string arg1_str(jarg1);
67328   arg1 = &arg1_str;
67329   if (!jarg2) {
67330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67331     return 0;
67332   }
67333   std::string arg2_str(jarg2);
67334   arg2 = &arg2_str;
67335   if (!jarg3) {
67336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67337     return 0;
67338   }
67339   std::string arg3_str(jarg3);
67340   arg3 = &arg3_str;
67341   {
67342     try {
67343       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67344     } catch (std::out_of_range& e) {
67345       {
67346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67347       };
67348     } catch (std::exception& e) {
67349       {
67350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67351       };
67352     } catch (Dali::DaliException e) {
67353       {
67354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67355       };
67356     } catch (...) {
67357       {
67358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67359       };
67360     }
67361   }
67362
67363   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67364
67365   //argout typemap for const std::string&
67366
67367
67368   //argout typemap for const std::string&
67369
67370
67371   //argout typemap for const std::string&
67372
67373   return jresult;
67374 }
67375
67376
67377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67378   void * jresult ;
67379   Dali::Toolkit::Model3dView *result = 0 ;
67380
67381   {
67382     try {
67383       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67384     } catch (std::out_of_range& e) {
67385       {
67386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67387       };
67388     } catch (std::exception& e) {
67389       {
67390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67391       };
67392     } catch (Dali::DaliException e) {
67393       {
67394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67399       };
67400     }
67401   }
67402
67403   jresult = (void *)result;
67404   return jresult;
67405 }
67406
67407
67408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67409   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67410
67411   arg1 = (Dali::Toolkit::Model3dView *)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 (Dali::DaliException e) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67430       };
67431     }
67432   }
67433
67434 }
67435
67436
67437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67438   void * jresult ;
67439   Dali::Toolkit::Model3dView *arg1 = 0 ;
67440   Dali::Toolkit::Model3dView *result = 0 ;
67441
67442   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67443   if (!arg1) {
67444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67445     return 0;
67446   }
67447   {
67448     try {
67449       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67457       };
67458     } catch (Dali::DaliException e) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67461       };
67462     } catch (...) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67465       };
67466     }
67467   }
67468
67469   jresult = (void *)result;
67470   return jresult;
67471 }
67472
67473
67474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67475   void * jresult ;
67476   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67477   Dali::Toolkit::Model3dView *arg2 = 0 ;
67478   Dali::Toolkit::Model3dView *result = 0 ;
67479
67480   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67481   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67482   if (!arg2) {
67483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67484     return 0;
67485   }
67486   {
67487     try {
67488       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67489     } catch (std::out_of_range& e) {
67490       {
67491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (std::exception& e) {
67494       {
67495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67496       };
67497     } catch (Dali::DaliException e) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67500       };
67501     } catch (...) {
67502       {
67503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67504       };
67505     }
67506   }
67507
67508   jresult = (void *)result;
67509   return jresult;
67510 }
67511
67512
67513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67514   void * jresult ;
67515   Dali::BaseHandle arg1 ;
67516   Dali::BaseHandle *argp1 ;
67517   Dali::Toolkit::Model3dView result;
67518
67519   argp1 = (Dali::BaseHandle *)jarg1;
67520   if (!argp1) {
67521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67522     return 0;
67523   }
67524   arg1 = *argp1;
67525   {
67526     try {
67527       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67528     } catch (std::out_of_range& e) {
67529       {
67530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67531       };
67532     } catch (std::exception& e) {
67533       {
67534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (Dali::DaliException e) {
67537       {
67538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67539       };
67540     } catch (...) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67543       };
67544     }
67545   }
67546
67547   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67548   return jresult;
67549 }
67550
67551
67552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67553   int jresult ;
67554   int result;
67555
67556   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67557   jresult = (int)result;
67558   return jresult;
67559 }
67560
67561
67562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67563   int jresult ;
67564   int result;
67565
67566   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67567   jresult = (int)result;
67568   return jresult;
67569 }
67570
67571
67572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67573   int jresult ;
67574   int result;
67575
67576   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67577   jresult = (int)result;
67578   return jresult;
67579 }
67580
67581
67582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67583   int jresult ;
67584   int result;
67585
67586   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67587   jresult = (int)result;
67588   return jresult;
67589 }
67590
67591
67592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67593   int jresult ;
67594   int result;
67595
67596   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67597   jresult = (int)result;
67598   return jresult;
67599 }
67600
67601
67602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67603   int jresult ;
67604   int result;
67605
67606   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67607   jresult = (int)result;
67608   return jresult;
67609 }
67610
67611
67612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67613   int jresult ;
67614   int result;
67615
67616   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67617   jresult = (int)result;
67618   return jresult;
67619 }
67620
67621
67622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67623   int jresult ;
67624   int result;
67625
67626   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67627   jresult = (int)result;
67628   return jresult;
67629 }
67630
67631
67632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67633   int jresult ;
67634   int result;
67635
67636   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67637   jresult = (int)result;
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67643   void * jresult ;
67644   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67645
67646   {
67647     try {
67648       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67649     } catch (std::out_of_range& e) {
67650       {
67651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67652       };
67653     } catch (std::exception& e) {
67654       {
67655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67656       };
67657     } catch (Dali::DaliException e) {
67658       {
67659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67660       };
67661     } catch (...) {
67662       {
67663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67664       };
67665     }
67666   }
67667
67668   jresult = (void *)result;
67669   return jresult;
67670 }
67671
67672
67673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67674   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67675
67676   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67677   {
67678     try {
67679       delete arg1;
67680     } catch (std::out_of_range& e) {
67681       {
67682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67683       };
67684     } catch (std::exception& e) {
67685       {
67686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67687       };
67688     } catch (Dali::DaliException e) {
67689       {
67690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67691       };
67692     } catch (...) {
67693       {
67694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67695       };
67696     }
67697   }
67698
67699 }
67700
67701
67702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67703   void * jresult ;
67704   Dali::Toolkit::ScrollBar *result = 0 ;
67705
67706   {
67707     try {
67708       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67709     } catch (std::out_of_range& e) {
67710       {
67711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67712       };
67713     } catch (std::exception& e) {
67714       {
67715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67716       };
67717     } catch (Dali::DaliException e) {
67718       {
67719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67720       };
67721     } catch (...) {
67722       {
67723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67724       };
67725     }
67726   }
67727
67728   jresult = (void *)result;
67729   return jresult;
67730 }
67731
67732
67733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67734   void * jresult ;
67735   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67736   Dali::Toolkit::ScrollBar *result = 0 ;
67737
67738   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67739   if (!arg1) {
67740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67741     return 0;
67742   }
67743   {
67744     try {
67745       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67746     } catch (std::out_of_range& e) {
67747       {
67748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67749       };
67750     } catch (std::exception& e) {
67751       {
67752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (Dali::DaliException e) {
67755       {
67756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67757       };
67758     } catch (...) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67761       };
67762     }
67763   }
67764
67765   jresult = (void *)result;
67766   return jresult;
67767 }
67768
67769
67770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67771   void * jresult ;
67772   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67773   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67774   Dali::Toolkit::ScrollBar *result = 0 ;
67775
67776   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67777   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67778   if (!arg2) {
67779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67780     return 0;
67781   }
67782   {
67783     try {
67784       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67785     } catch (std::out_of_range& e) {
67786       {
67787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (std::exception& e) {
67790       {
67791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (Dali::DaliException e) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67796       };
67797     } catch (...) {
67798       {
67799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67800       };
67801     }
67802   }
67803
67804   jresult = (void *)result;
67805   return jresult;
67806 }
67807
67808
67809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67810   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67811
67812   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67813   {
67814     try {
67815       delete arg1;
67816     } catch (std::out_of_range& e) {
67817       {
67818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67819       };
67820     } catch (std::exception& e) {
67821       {
67822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67823       };
67824     } catch (Dali::DaliException e) {
67825       {
67826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67827       };
67828     } catch (...) {
67829       {
67830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67831       };
67832     }
67833   }
67834
67835 }
67836
67837
67838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67839   void * jresult ;
67840   Dali::Toolkit::ScrollBar::Direction arg1 ;
67841   Dali::Toolkit::ScrollBar result;
67842
67843   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67844   {
67845     try {
67846       result = Dali::Toolkit::ScrollBar::New(arg1);
67847     } catch (std::out_of_range& e) {
67848       {
67849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67850       };
67851     } catch (std::exception& e) {
67852       {
67853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (Dali::DaliException e) {
67856       {
67857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67858       };
67859     } catch (...) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67862       };
67863     }
67864   }
67865
67866   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67867   return jresult;
67868 }
67869
67870
67871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67872   void * jresult ;
67873   Dali::Toolkit::ScrollBar result;
67874
67875   {
67876     try {
67877       result = Dali::Toolkit::ScrollBar::New();
67878     } catch (std::out_of_range& e) {
67879       {
67880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67881       };
67882     } catch (std::exception& e) {
67883       {
67884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67885       };
67886     } catch (Dali::DaliException e) {
67887       {
67888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67889       };
67890     } catch (...) {
67891       {
67892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67893       };
67894     }
67895   }
67896
67897   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67898   return jresult;
67899 }
67900
67901
67902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67903   void * jresult ;
67904   Dali::BaseHandle arg1 ;
67905   Dali::BaseHandle *argp1 ;
67906   Dali::Toolkit::ScrollBar result;
67907
67908   argp1 = (Dali::BaseHandle *)jarg1;
67909   if (!argp1) {
67910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67911     return 0;
67912   }
67913   arg1 = *argp1;
67914   {
67915     try {
67916       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67917     } catch (std::out_of_range& e) {
67918       {
67919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67920       };
67921     } catch (std::exception& e) {
67922       {
67923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67924       };
67925     } catch (Dali::DaliException e) {
67926       {
67927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67928       };
67929     } catch (...) {
67930       {
67931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67932       };
67933     }
67934   }
67935
67936   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67937   return jresult;
67938 }
67939
67940
67941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67942   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67943   Dali::Handle arg2 ;
67944   Dali::Property::Index arg3 ;
67945   Dali::Property::Index arg4 ;
67946   Dali::Property::Index arg5 ;
67947   Dali::Property::Index arg6 ;
67948   Dali::Handle *argp2 ;
67949
67950   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67951   argp2 = (Dali::Handle *)jarg2;
67952   if (!argp2) {
67953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67954     return ;
67955   }
67956   arg2 = *argp2;
67957   arg3 = (Dali::Property::Index)jarg3;
67958   arg4 = (Dali::Property::Index)jarg4;
67959   arg5 = (Dali::Property::Index)jarg5;
67960   arg6 = (Dali::Property::Index)jarg6;
67961   {
67962     try {
67963       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67964     } catch (std::out_of_range& e) {
67965       {
67966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67967       };
67968     } catch (std::exception& e) {
67969       {
67970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67971       };
67972     } catch (Dali::DaliException e) {
67973       {
67974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67975       };
67976     } catch (...) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67979       };
67980     }
67981   }
67982
67983 }
67984
67985
67986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67987   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67988   Dali::Actor arg2 ;
67989   Dali::Actor *argp2 ;
67990
67991   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67992   argp2 = (Dali::Actor *)jarg2;
67993   if (!argp2) {
67994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67995     return ;
67996   }
67997   arg2 = *argp2;
67998   {
67999     try {
68000       (arg1)->SetScrollIndicator(arg2);
68001     } catch (std::out_of_range& e) {
68002       {
68003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68004       };
68005     } catch (std::exception& e) {
68006       {
68007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68008       };
68009     } catch (Dali::DaliException e) {
68010       {
68011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68012       };
68013     } catch (...) {
68014       {
68015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68016       };
68017     }
68018   }
68019
68020 }
68021
68022
68023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68024   void * jresult ;
68025   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68026   Dali::Actor result;
68027
68028   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68029   {
68030     try {
68031       result = (arg1)->GetScrollIndicator();
68032     } catch (std::out_of_range& e) {
68033       {
68034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68035       };
68036     } catch (std::exception& e) {
68037       {
68038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (Dali::DaliException e) {
68041       {
68042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68043       };
68044     } catch (...) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68047       };
68048     }
68049   }
68050
68051   jresult = new Dali::Actor((const Dali::Actor &)result);
68052   return jresult;
68053 }
68054
68055
68056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68057   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68058   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68059
68060   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68061   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68062   if (!arg2) {
68063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68064     return ;
68065   }
68066   {
68067     try {
68068       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68069     } catch (std::out_of_range& e) {
68070       {
68071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68072       };
68073     } catch (std::exception& e) {
68074       {
68075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68076       };
68077     } catch (Dali::DaliException e) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68080       };
68081     } catch (...) {
68082       {
68083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68084       };
68085     }
68086   }
68087
68088 }
68089
68090
68091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68092   void * jresult ;
68093   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68094
68095   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68096   {
68097     try {
68098       jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)(((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals()));
68099     } catch (std::out_of_range& e) {
68100       {
68101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68102       };
68103     } catch (std::exception& e) {
68104       {
68105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68106       };
68107     } catch (...) {
68108       {
68109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68110       };
68111     }
68112   }
68113   return jresult;
68114 }
68115
68116
68117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68118   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68119   Dali::Toolkit::ScrollBar::Direction arg2 ;
68120
68121   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68122   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68123   {
68124     try {
68125       (arg1)->SetScrollDirection(arg2);
68126     } catch (std::out_of_range& e) {
68127       {
68128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (std::exception& e) {
68131       {
68132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68133       };
68134     } catch (Dali::DaliException e) {
68135       {
68136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68137       };
68138     } catch (...) {
68139       {
68140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68141       };
68142     }
68143   }
68144
68145 }
68146
68147
68148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68149   int jresult ;
68150   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68151   Dali::Toolkit::ScrollBar::Direction result;
68152
68153   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68154   {
68155     try {
68156       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68157     } catch (std::out_of_range& e) {
68158       {
68159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68160       };
68161     } catch (std::exception& e) {
68162       {
68163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68164       };
68165     } catch (Dali::DaliException e) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68172       };
68173     }
68174   }
68175
68176   jresult = (int)result;
68177   return jresult;
68178 }
68179
68180
68181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68182   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68183   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68184
68185   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68186   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68187   {
68188     try {
68189       (arg1)->SetIndicatorHeightPolicy(arg2);
68190     } catch (std::out_of_range& e) {
68191       {
68192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68193       };
68194     } catch (std::exception& e) {
68195       {
68196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68197       };
68198     } catch (Dali::DaliException e) {
68199       {
68200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68201       };
68202     } catch (...) {
68203       {
68204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68205       };
68206     }
68207   }
68208
68209 }
68210
68211
68212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68213   int jresult ;
68214   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68215   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68216
68217   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68218   {
68219     try {
68220       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68221     } catch (std::out_of_range& e) {
68222       {
68223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68224       };
68225     } catch (std::exception& e) {
68226       {
68227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68228       };
68229     } catch (Dali::DaliException e) {
68230       {
68231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68232       };
68233     } catch (...) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68236       };
68237     }
68238   }
68239
68240   jresult = (int)result;
68241   return jresult;
68242 }
68243
68244
68245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68246   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68247   float arg2 ;
68248
68249   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68250   arg2 = (float)jarg2;
68251   {
68252     try {
68253       (arg1)->SetIndicatorFixedHeight(arg2);
68254     } catch (std::out_of_range& e) {
68255       {
68256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68257       };
68258     } catch (std::exception& e) {
68259       {
68260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68261       };
68262     } catch (Dali::DaliException e) {
68263       {
68264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68265       };
68266     } catch (...) {
68267       {
68268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68269       };
68270     }
68271   }
68272
68273 }
68274
68275
68276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68277   float jresult ;
68278   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68279   float result;
68280
68281   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68282   {
68283     try {
68284       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68285     } catch (std::out_of_range& e) {
68286       {
68287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68288       };
68289     } catch (std::exception& e) {
68290       {
68291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (Dali::DaliException e) {
68294       {
68295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68296       };
68297     } catch (...) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68300       };
68301     }
68302   }
68303
68304   jresult = result;
68305   return jresult;
68306 }
68307
68308
68309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68310   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68311   float arg2 ;
68312
68313   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68314   arg2 = (float)jarg2;
68315   {
68316     try {
68317       (arg1)->SetIndicatorShowDuration(arg2);
68318     } catch (std::out_of_range& e) {
68319       {
68320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68321       };
68322     } catch (std::exception& e) {
68323       {
68324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68325       };
68326     } catch (Dali::DaliException e) {
68327       {
68328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68329       };
68330     } catch (...) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68333       };
68334     }
68335   }
68336
68337 }
68338
68339
68340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68341   float jresult ;
68342   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68343   float result;
68344
68345   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68346   {
68347     try {
68348       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68349     } catch (std::out_of_range& e) {
68350       {
68351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68352       };
68353     } catch (std::exception& e) {
68354       {
68355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68356       };
68357     } catch (Dali::DaliException e) {
68358       {
68359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68360       };
68361     } catch (...) {
68362       {
68363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68364       };
68365     }
68366   }
68367
68368   jresult = result;
68369   return jresult;
68370 }
68371
68372
68373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68375   float arg2 ;
68376
68377   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68378   arg2 = (float)jarg2;
68379   {
68380     try {
68381       (arg1)->SetIndicatorHideDuration(arg2);
68382     } catch (std::out_of_range& e) {
68383       {
68384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68385       };
68386     } catch (std::exception& e) {
68387       {
68388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68389       };
68390     } catch (Dali::DaliException e) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68393       };
68394     } catch (...) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68397       };
68398     }
68399   }
68400
68401 }
68402
68403
68404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68405   float jresult ;
68406   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68407   float result;
68408
68409   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68410   {
68411     try {
68412       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68413     } catch (std::out_of_range& e) {
68414       {
68415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68416       };
68417     } catch (std::exception& e) {
68418       {
68419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68420       };
68421     } catch (Dali::DaliException e) {
68422       {
68423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68424       };
68425     } catch (...) {
68426       {
68427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68428       };
68429     }
68430   }
68431
68432   jresult = result;
68433   return jresult;
68434 }
68435
68436
68437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68438   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68439
68440   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68441   {
68442     try {
68443       (arg1)->ShowIndicator();
68444     } catch (std::out_of_range& e) {
68445       {
68446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68447       };
68448     } catch (std::exception& e) {
68449       {
68450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68451       };
68452     } catch (Dali::DaliException e) {
68453       {
68454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68455       };
68456     } catch (...) {
68457       {
68458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68459       };
68460     }
68461   }
68462
68463 }
68464
68465
68466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68467   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68468
68469   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68470   {
68471     try {
68472       (arg1)->HideIndicator();
68473     } catch (std::out_of_range& e) {
68474       {
68475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68476       };
68477     } catch (std::exception& e) {
68478       {
68479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68480       };
68481     } catch (Dali::DaliException e) {
68482       {
68483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68484       };
68485     } catch (...) {
68486       {
68487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68488       };
68489     }
68490   }
68491
68492 }
68493
68494
68495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68496   void * jresult ;
68497   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68498   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68499
68500   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68501   {
68502     try {
68503       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68504     } catch (std::out_of_range& e) {
68505       {
68506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68507       };
68508     } catch (std::exception& e) {
68509       {
68510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68511       };
68512     } catch (Dali::DaliException e) {
68513       {
68514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68515       };
68516     } catch (...) {
68517       {
68518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68519       };
68520     }
68521   }
68522
68523   jresult = (void *)result;
68524   return jresult;
68525 }
68526
68527
68528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68529   void * jresult ;
68530   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68531   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68532
68533   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68534   {
68535     try {
68536       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68537     } catch (std::out_of_range& e) {
68538       {
68539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68540       };
68541     } catch (std::exception& e) {
68542       {
68543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68544       };
68545     } catch (Dali::DaliException e) {
68546       {
68547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68548       };
68549     } catch (...) {
68550       {
68551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68552       };
68553     }
68554   }
68555
68556   jresult = (void *)result;
68557   return jresult;
68558 }
68559
68560
68561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68562   int jresult ;
68563   int result;
68564
68565   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68566   jresult = (int)result;
68567   return jresult;
68568 }
68569
68570
68571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68572   int jresult ;
68573   int result;
68574
68575   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68576   jresult = (int)result;
68577   return jresult;
68578 }
68579
68580
68581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68582   int jresult ;
68583   int result;
68584
68585   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68586   jresult = (int)result;
68587   return jresult;
68588 }
68589
68590
68591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68592   int jresult ;
68593   int result;
68594
68595   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68596   jresult = (int)result;
68597   return jresult;
68598 }
68599
68600
68601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68602   int jresult ;
68603   int result;
68604
68605   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68606   jresult = (int)result;
68607   return jresult;
68608 }
68609
68610
68611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68612   int jresult ;
68613   int result;
68614
68615   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68616   jresult = (int)result;
68617   return jresult;
68618 }
68619
68620
68621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68622   int jresult ;
68623   int result;
68624
68625   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68626   jresult = (int)result;
68627   return jresult;
68628 }
68629
68630
68631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68632   int jresult ;
68633   int result;
68634
68635   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68636   jresult = (int)result;
68637   return jresult;
68638 }
68639
68640
68641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68642   int jresult ;
68643   int result;
68644
68645   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68646   jresult = (int)result;
68647   return jresult;
68648 }
68649
68650
68651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68652   int jresult ;
68653   int result;
68654
68655   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68656   jresult = (int)result;
68657   return jresult;
68658 }
68659
68660
68661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68662   int jresult ;
68663   int result;
68664
68665   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68666   jresult = (int)result;
68667   return jresult;
68668 }
68669
68670
68671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68672   int jresult ;
68673   int result;
68674
68675   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68676   jresult = (int)result;
68677   return jresult;
68678 }
68679
68680
68681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68682   int jresult ;
68683   int result;
68684
68685   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68686   jresult = (int)result;
68687   return jresult;
68688 }
68689
68690
68691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68692   int jresult ;
68693   int result;
68694
68695   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68696   jresult = (int)result;
68697   return jresult;
68698 }
68699
68700
68701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68702   void * jresult ;
68703   Dali::Toolkit::Scrollable::Property *result = 0 ;
68704
68705   {
68706     try {
68707       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68708     } catch (std::out_of_range& e) {
68709       {
68710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68711       };
68712     } catch (std::exception& e) {
68713       {
68714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68715       };
68716     } catch (Dali::DaliException e) {
68717       {
68718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68719       };
68720     } catch (...) {
68721       {
68722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68723       };
68724     }
68725   }
68726
68727   jresult = (void *)result;
68728   return jresult;
68729 }
68730
68731
68732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68733   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68734
68735   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68736   {
68737     try {
68738       delete arg1;
68739     } catch (std::out_of_range& e) {
68740       {
68741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68742       };
68743     } catch (std::exception& e) {
68744       {
68745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68746       };
68747     } catch (Dali::DaliException e) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68750       };
68751     } catch (...) {
68752       {
68753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68754       };
68755     }
68756   }
68757
68758 }
68759
68760
68761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68762   void * jresult ;
68763   Dali::Toolkit::Scrollable *result = 0 ;
68764
68765   {
68766     try {
68767       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68768     } catch (std::out_of_range& e) {
68769       {
68770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (std::exception& e) {
68773       {
68774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (Dali::DaliException e) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786
68787   jresult = (void *)result;
68788   return jresult;
68789 }
68790
68791
68792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68793   void * jresult ;
68794   Dali::Toolkit::Scrollable *arg1 = 0 ;
68795   Dali::Toolkit::Scrollable *result = 0 ;
68796
68797   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68798   if (!arg1) {
68799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68800     return 0;
68801   }
68802   {
68803     try {
68804       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68805     } catch (std::out_of_range& e) {
68806       {
68807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68808       };
68809     } catch (std::exception& e) {
68810       {
68811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68812       };
68813     } catch (Dali::DaliException e) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68816       };
68817     } catch (...) {
68818       {
68819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68820       };
68821     }
68822   }
68823
68824   jresult = (void *)result;
68825   return jresult;
68826 }
68827
68828
68829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68830   void * jresult ;
68831   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68832   Dali::Toolkit::Scrollable *arg2 = 0 ;
68833   Dali::Toolkit::Scrollable *result = 0 ;
68834
68835   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68836   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68837   if (!arg2) {
68838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68839     return 0;
68840   }
68841   {
68842     try {
68843       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68844     } catch (std::out_of_range& e) {
68845       {
68846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68847       };
68848     } catch (std::exception& e) {
68849       {
68850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68851       };
68852     } catch (Dali::DaliException e) {
68853       {
68854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68855       };
68856     } catch (...) {
68857       {
68858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68859       };
68860     }
68861   }
68862
68863   jresult = (void *)result;
68864   return jresult;
68865 }
68866
68867
68868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68869   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68870
68871   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68872   {
68873     try {
68874       delete arg1;
68875     } catch (std::out_of_range& e) {
68876       {
68877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68878       };
68879     } catch (std::exception& e) {
68880       {
68881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68882       };
68883     } catch (Dali::DaliException e) {
68884       {
68885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68886       };
68887     } catch (...) {
68888       {
68889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68890       };
68891     }
68892   }
68893
68894 }
68895
68896
68897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68898   void * jresult ;
68899   Dali::BaseHandle arg1 ;
68900   Dali::BaseHandle *argp1 ;
68901   Dali::Toolkit::Scrollable result;
68902
68903   argp1 = (Dali::BaseHandle *)jarg1;
68904   if (!argp1) {
68905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68906     return 0;
68907   }
68908   arg1 = *argp1;
68909   {
68910     try {
68911       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68912     } catch (std::out_of_range& e) {
68913       {
68914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68915       };
68916     } catch (std::exception& e) {
68917       {
68918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68919       };
68920     } catch (Dali::DaliException e) {
68921       {
68922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68923       };
68924     } catch (...) {
68925       {
68926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68927       };
68928     }
68929   }
68930
68931   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68932   return jresult;
68933 }
68934
68935
68936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68937   unsigned int jresult ;
68938   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68939   bool result;
68940
68941   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68942   {
68943     try {
68944       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68952       };
68953     } catch (Dali::DaliException e) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68956       };
68957     } catch (...) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68960       };
68961     }
68962   }
68963
68964   jresult = result;
68965   return jresult;
68966 }
68967
68968
68969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68970   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68971   bool arg2 ;
68972
68973   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68974   arg2 = jarg2 ? true : false;
68975   {
68976     try {
68977       (arg1)->SetOvershootEnabled(arg2);
68978     } catch (std::out_of_range& e) {
68979       {
68980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68981       };
68982     } catch (std::exception& e) {
68983       {
68984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68985       };
68986     } catch (Dali::DaliException e) {
68987       {
68988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68989       };
68990     } catch (...) {
68991       {
68992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68993       };
68994     }
68995   }
68996
68997 }
68998
68999
69000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69001   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69002   Dali::Vector4 *arg2 = 0 ;
69003
69004   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69005   arg2 = (Dali::Vector4 *)jarg2;
69006   if (!arg2) {
69007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69008     return ;
69009   }
69010   {
69011     try {
69012       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69013     } catch (std::out_of_range& e) {
69014       {
69015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69016       };
69017     } catch (std::exception& e) {
69018       {
69019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69020       };
69021     } catch (Dali::DaliException e) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69024       };
69025     } catch (...) {
69026       {
69027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69028       };
69029     }
69030   }
69031
69032 }
69033
69034
69035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69036   void * jresult ;
69037   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69038   Dali::Vector4 result;
69039
69040   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69041   {
69042     try {
69043       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69044     } catch (std::out_of_range& e) {
69045       {
69046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69047       };
69048     } catch (std::exception& e) {
69049       {
69050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69051       };
69052     } catch (Dali::DaliException e) {
69053       {
69054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69055       };
69056     } catch (...) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69059       };
69060     }
69061   }
69062
69063   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69064   return jresult;
69065 }
69066
69067
69068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69069   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69070   float arg2 ;
69071
69072   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69073   arg2 = (float)jarg2;
69074   {
69075     try {
69076       (arg1)->SetOvershootAnimationSpeed(arg2);
69077     } catch (std::out_of_range& e) {
69078       {
69079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69080       };
69081     } catch (std::exception& e) {
69082       {
69083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69084       };
69085     } catch (Dali::DaliException e) {
69086       {
69087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69088       };
69089     } catch (...) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69092       };
69093     }
69094   }
69095
69096 }
69097
69098
69099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69100   float jresult ;
69101   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69102   float result;
69103
69104   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69105   {
69106     try {
69107       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69108     } catch (std::out_of_range& e) {
69109       {
69110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69111       };
69112     } catch (std::exception& e) {
69113       {
69114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69115       };
69116     } catch (Dali::DaliException e) {
69117       {
69118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69119       };
69120     } catch (...) {
69121       {
69122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69123       };
69124     }
69125   }
69126
69127   jresult = result;
69128   return jresult;
69129 }
69130
69131
69132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69133   void * jresult ;
69134   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69135   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69136
69137   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69138   {
69139     try {
69140       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69141     } catch (std::out_of_range& e) {
69142       {
69143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (std::exception& e) {
69146       {
69147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (Dali::DaliException e) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69152       };
69153     } catch (...) {
69154       {
69155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69156       };
69157     }
69158   }
69159
69160   jresult = (void *)result;
69161   return jresult;
69162 }
69163
69164
69165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69166   void * jresult ;
69167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69168   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69169
69170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69171   {
69172     try {
69173       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69174     } catch (std::out_of_range& e) {
69175       {
69176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69177       };
69178     } catch (std::exception& e) {
69179       {
69180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69181       };
69182     } catch (Dali::DaliException e) {
69183       {
69184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69185       };
69186     } catch (...) {
69187       {
69188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69189       };
69190     }
69191   }
69192
69193   jresult = (void *)result;
69194   return jresult;
69195 }
69196
69197
69198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69199   void * jresult ;
69200   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69201   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69202
69203   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69204   {
69205     try {
69206       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (Dali::DaliException e) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225
69226   jresult = (void *)result;
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69232   unsigned int jresult ;
69233   Dali::Toolkit::ControlOrientation::Type arg1 ;
69234   bool result;
69235
69236   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69237   {
69238     try {
69239       result = (bool)Dali::Toolkit::IsVertical(arg1);
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (Dali::DaliException e) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69255       };
69256     }
69257   }
69258
69259   jresult = result;
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69265   unsigned int jresult ;
69266   Dali::Toolkit::ControlOrientation::Type arg1 ;
69267   bool result;
69268
69269   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69270   {
69271     try {
69272       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69273     } catch (std::out_of_range& e) {
69274       {
69275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (std::exception& e) {
69278       {
69279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69280       };
69281     } catch (Dali::DaliException e) {
69282       {
69283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69284       };
69285     } catch (...) {
69286       {
69287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69288       };
69289     }
69290   }
69291
69292   jresult = result;
69293   return jresult;
69294 }
69295
69296
69297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69298   void * jresult ;
69299   unsigned int arg1 ;
69300   unsigned int arg2 ;
69301   Dali::Toolkit::ItemRange *result = 0 ;
69302
69303   arg1 = (unsigned int)jarg1;
69304   arg2 = (unsigned int)jarg2;
69305   {
69306     try {
69307       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69308     } catch (std::out_of_range& e) {
69309       {
69310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (std::exception& e) {
69313       {
69314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69315       };
69316     } catch (Dali::DaliException e) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69319       };
69320     } catch (...) {
69321       {
69322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69323       };
69324     }
69325   }
69326
69327   jresult = (void *)result;
69328   return jresult;
69329 }
69330
69331
69332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69333   void * jresult ;
69334   Dali::Toolkit::ItemRange *arg1 = 0 ;
69335   Dali::Toolkit::ItemRange *result = 0 ;
69336
69337   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69338   if (!arg1) {
69339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69340     return 0;
69341   }
69342   {
69343     try {
69344       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69345     } catch (std::out_of_range& e) {
69346       {
69347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69348       };
69349     } catch (std::exception& e) {
69350       {
69351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69352       };
69353     } catch (Dali::DaliException e) {
69354       {
69355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69356       };
69357     } catch (...) {
69358       {
69359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69360       };
69361     }
69362   }
69363
69364   jresult = (void *)result;
69365   return jresult;
69366 }
69367
69368
69369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69370   void * jresult ;
69371   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69372   Dali::Toolkit::ItemRange *arg2 = 0 ;
69373   Dali::Toolkit::ItemRange *result = 0 ;
69374
69375   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69376   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69377   if (!arg2) {
69378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69379     return 0;
69380   }
69381   {
69382     try {
69383       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69384     } catch (std::out_of_range& e) {
69385       {
69386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69387       };
69388     } catch (std::exception& e) {
69389       {
69390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69391       };
69392     } catch (Dali::DaliException e) {
69393       {
69394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69395       };
69396     } catch (...) {
69397       {
69398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69399       };
69400     }
69401   }
69402
69403   jresult = (void *)result;
69404   return jresult;
69405 }
69406
69407
69408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69409   unsigned int jresult ;
69410   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69411   unsigned int arg2 ;
69412   bool result;
69413
69414   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69415   arg2 = (unsigned int)jarg2;
69416   {
69417     try {
69418       result = (bool)(arg1)->Within(arg2);
69419     } catch (std::out_of_range& e) {
69420       {
69421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69422       };
69423     } catch (std::exception& e) {
69424       {
69425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69426       };
69427     } catch (Dali::DaliException e) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69430       };
69431     } catch (...) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69434       };
69435     }
69436   }
69437
69438   jresult = result;
69439   return jresult;
69440 }
69441
69442
69443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69444   void * jresult ;
69445   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69446   Dali::Toolkit::ItemRange *arg2 = 0 ;
69447   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69448
69449   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69450   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69451   if (!arg2) {
69452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69453     return 0;
69454   }
69455   {
69456     try {
69457       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69458     } catch (std::out_of_range& e) {
69459       {
69460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69461       };
69462     } catch (std::exception& e) {
69463       {
69464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69465       };
69466     } catch (Dali::DaliException e) {
69467       {
69468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69469       };
69470     } catch (...) {
69471       {
69472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69473       };
69474     }
69475   }
69476
69477   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69478   return jresult;
69479 }
69480
69481
69482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69483   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69484   unsigned int arg2 ;
69485
69486   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69487   arg2 = (unsigned int)jarg2;
69488   if (arg1) (arg1)->begin = arg2;
69489 }
69490
69491
69492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69493   unsigned int jresult ;
69494   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69495   unsigned int result;
69496
69497   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69498   result = (unsigned int) ((arg1)->begin);
69499   jresult = result;
69500   return jresult;
69501 }
69502
69503
69504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69505   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69506   unsigned int arg2 ;
69507
69508   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69509   arg2 = (unsigned int)jarg2;
69510   if (arg1) (arg1)->end = arg2;
69511 }
69512
69513
69514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69515   unsigned int jresult ;
69516   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69517   unsigned int result;
69518
69519   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69520   result = (unsigned int) ((arg1)->end);
69521   jresult = result;
69522   return jresult;
69523 }
69524
69525
69526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69527   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69528
69529   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69530   {
69531     try {
69532       delete arg1;
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69540       };
69541     } catch (Dali::DaliException e) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69544       };
69545     } catch (...) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69548       };
69549     }
69550   }
69551
69552 }
69553
69554
69555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69556   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69557
69558   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69559   {
69560     try {
69561       delete arg1;
69562     } catch (std::out_of_range& e) {
69563       {
69564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69565       };
69566     } catch (std::exception& e) {
69567       {
69568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69569       };
69570     } catch (Dali::DaliException e) {
69571       {
69572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69573       };
69574     } catch (...) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69577       };
69578     }
69579   }
69580
69581 }
69582
69583
69584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69585   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69586   Dali::Toolkit::ControlOrientation::Type arg2 ;
69587
69588   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69589   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69590   {
69591     try {
69592       (arg1)->SetOrientation(arg2);
69593     } catch (std::out_of_range& e) {
69594       {
69595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69596       };
69597     } catch (std::exception& e) {
69598       {
69599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69600       };
69601     } catch (Dali::DaliException e) {
69602       {
69603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69604       };
69605     } catch (...) {
69606       {
69607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69608       };
69609     }
69610   }
69611
69612 }
69613
69614
69615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69616   int jresult ;
69617   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69618   Dali::Toolkit::ControlOrientation::Type result;
69619
69620   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69621   {
69622     try {
69623       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69624     } catch (std::out_of_range& e) {
69625       {
69626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69627       };
69628     } catch (std::exception& e) {
69629       {
69630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69631       };
69632     } catch (Dali::DaliException e) {
69633       {
69634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69635       };
69636     } catch (...) {
69637       {
69638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69639       };
69640     }
69641   }
69642
69643   jresult = (int)result;
69644   return jresult;
69645 }
69646
69647
69648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69650   Dali::Property::Map *arg2 = 0 ;
69651
69652   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69653   arg2 = (Dali::Property::Map *)jarg2;
69654   if (!arg2) {
69655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69656     return ;
69657   }
69658   {
69659     try {
69660       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69661     } catch (std::out_of_range& e) {
69662       {
69663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69664       };
69665     } catch (std::exception& e) {
69666       {
69667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69668       };
69669     } catch (Dali::DaliException e) {
69670       {
69671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69672       };
69673     } catch (...) {
69674       {
69675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69676       };
69677     }
69678   }
69679
69680 }
69681
69682
69683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69684   void * jresult ;
69685   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69686   Dali::Property::Map result;
69687
69688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69689   {
69690     try {
69691       result = (arg1)->GetLayoutProperties();
69692     } catch (std::out_of_range& e) {
69693       {
69694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69695       };
69696     } catch (std::exception& e) {
69697       {
69698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69699       };
69700     } catch (Dali::DaliException e) {
69701       {
69702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69703       };
69704     } catch (...) {
69705       {
69706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69707       };
69708     }
69709   }
69710
69711   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69712   return jresult;
69713 }
69714
69715
69716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69717   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69718   unsigned int arg2 ;
69719   Dali::Vector3 *arg3 = 0 ;
69720   Dali::Vector3 *arg4 = 0 ;
69721
69722   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69723   arg2 = (unsigned int)jarg2;
69724   arg3 = (Dali::Vector3 *)jarg3;
69725   if (!arg3) {
69726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69727     return ;
69728   }
69729   arg4 = (Dali::Vector3 *)jarg4;
69730   if (!arg4) {
69731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69732     return ;
69733   }
69734   {
69735     try {
69736       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69737     } catch (std::out_of_range& e) {
69738       {
69739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69740       };
69741     } catch (std::exception& e) {
69742       {
69743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69744       };
69745     } catch (Dali::DaliException e) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69748       };
69749     } catch (...) {
69750       {
69751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69752       };
69753     }
69754   }
69755
69756 }
69757
69758
69759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69760   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69761   Dali::Vector3 *arg2 = 0 ;
69762
69763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69764   arg2 = (Dali::Vector3 *)jarg2;
69765   if (!arg2) {
69766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69767     return ;
69768   }
69769   {
69770     try {
69771       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69772     } catch (std::out_of_range& e) {
69773       {
69774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69775       };
69776     } catch (std::exception& e) {
69777       {
69778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69779       };
69780     } catch (Dali::DaliException e) {
69781       {
69782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69787       };
69788     }
69789   }
69790
69791 }
69792
69793
69794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69795   float jresult ;
69796   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69797   unsigned int arg2 ;
69798   Dali::Vector3 arg3 ;
69799   Dali::Vector3 *argp3 ;
69800   float result;
69801
69802   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69803   arg2 = (unsigned int)jarg2;
69804   argp3 = (Dali::Vector3 *)jarg3;
69805   if (!argp3) {
69806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69807     return 0;
69808   }
69809   arg3 = *argp3;
69810   {
69811     try {
69812       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69813     } catch (std::out_of_range& e) {
69814       {
69815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69816       };
69817     } catch (std::exception& e) {
69818       {
69819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69820       };
69821     } catch (Dali::DaliException e) {
69822       {
69823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69824       };
69825     } catch (...) {
69826       {
69827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69828       };
69829     }
69830   }
69831
69832   jresult = result;
69833   return jresult;
69834 }
69835
69836
69837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69838   float jresult ;
69839   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69840   float arg2 ;
69841   float result;
69842
69843   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69844   arg2 = (float)jarg2;
69845   {
69846     try {
69847       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69848     } catch (std::out_of_range& e) {
69849       {
69850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (std::exception& e) {
69853       {
69854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (Dali::DaliException e) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69863       };
69864     }
69865   }
69866
69867   jresult = result;
69868   return jresult;
69869 }
69870
69871
69872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69873   float jresult ;
69874   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69875   unsigned int arg2 ;
69876   float result;
69877
69878   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69879   arg2 = (unsigned int)jarg2;
69880   {
69881     try {
69882       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69890       };
69891     } catch (Dali::DaliException e) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69894       };
69895     } catch (...) {
69896       {
69897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69898       };
69899     }
69900   }
69901
69902   jresult = result;
69903   return jresult;
69904 }
69905
69906
69907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69908   void * jresult ;
69909   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69910   float arg2 ;
69911   Dali::Vector3 arg3 ;
69912   Dali::Vector3 *argp3 ;
69913   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69914
69915   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69916   arg2 = (float)jarg2;
69917   argp3 = (Dali::Vector3 *)jarg3;
69918   if (!argp3) {
69919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69920     return 0;
69921   }
69922   arg3 = *argp3;
69923   {
69924     try {
69925       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69926     } catch (std::out_of_range& e) {
69927       {
69928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69929       };
69930     } catch (std::exception& e) {
69931       {
69932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69933       };
69934     } catch (Dali::DaliException e) {
69935       {
69936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69937       };
69938     } catch (...) {
69939       {
69940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69941       };
69942     }
69943   }
69944
69945   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69946   return jresult;
69947 }
69948
69949
69950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69951   float jresult ;
69952   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69953   int arg2 ;
69954   float arg3 ;
69955   Dali::Vector3 *arg4 = 0 ;
69956   float result;
69957
69958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69959   arg2 = (int)jarg2;
69960   arg3 = (float)jarg3;
69961   arg4 = (Dali::Vector3 *)jarg4;
69962   if (!arg4) {
69963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69964     return 0;
69965   }
69966   {
69967     try {
69968       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69969     } catch (std::out_of_range& e) {
69970       {
69971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69972       };
69973     } catch (std::exception& e) {
69974       {
69975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69976       };
69977     } catch (Dali::DaliException e) {
69978       {
69979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69980       };
69981     } catch (...) {
69982       {
69983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69984       };
69985     }
69986   }
69987
69988   jresult = result;
69989   return jresult;
69990 }
69991
69992
69993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69994   unsigned int jresult ;
69995   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69996   Dali::Vector3 arg2 ;
69997   Dali::Vector3 *argp2 ;
69998   unsigned int result;
69999
70000   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70001   argp2 = (Dali::Vector3 *)jarg2;
70002   if (!argp2) {
70003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70004     return 0;
70005   }
70006   arg2 = *argp2;
70007   {
70008     try {
70009       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70010     } catch (std::out_of_range& e) {
70011       {
70012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70013       };
70014     } catch (std::exception& e) {
70015       {
70016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (Dali::DaliException e) {
70019       {
70020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70021       };
70022     } catch (...) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70025       };
70026     }
70027   }
70028
70029   jresult = result;
70030   return jresult;
70031 }
70032
70033
70034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70035   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70036   unsigned int arg2 ;
70037   Dali::Vector3 *arg3 = 0 ;
70038   Dali::Vector3 *arg4 = 0 ;
70039
70040   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70041   arg2 = (unsigned int)jarg2;
70042   arg3 = (Dali::Vector3 *)jarg3;
70043   if (!arg3) {
70044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70045     return ;
70046   }
70047   arg4 = (Dali::Vector3 *)jarg4;
70048   if (!arg4) {
70049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70050     return ;
70051   }
70052   {
70053     try {
70054       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70055     } catch (std::out_of_range& e) {
70056       {
70057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70058       };
70059     } catch (std::exception& e) {
70060       {
70061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70062       };
70063     } catch (Dali::DaliException e) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70066       };
70067     } catch (...) {
70068       {
70069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70070       };
70071     }
70072   }
70073
70074 }
70075
70076
70077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70078   void * jresult ;
70079   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70080   Dali::Degree result;
70081
70082   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70083   {
70084     try {
70085       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70086     } catch (std::out_of_range& e) {
70087       {
70088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (std::exception& e) {
70091       {
70092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70093       };
70094     } catch (Dali::DaliException e) {
70095       {
70096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70097       };
70098     } catch (...) {
70099       {
70100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70101       };
70102     }
70103   }
70104
70105   jresult = new Dali::Degree((const Dali::Degree &)result);
70106   return jresult;
70107 }
70108
70109
70110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70111   float jresult ;
70112   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70113   float result;
70114
70115   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70116   {
70117     try {
70118       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70119     } catch (std::out_of_range& e) {
70120       {
70121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70122       };
70123     } catch (std::exception& e) {
70124       {
70125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70126       };
70127     } catch (Dali::DaliException e) {
70128       {
70129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70130       };
70131     } catch (...) {
70132       {
70133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70134       };
70135     }
70136   }
70137
70138   jresult = result;
70139   return jresult;
70140 }
70141
70142
70143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70144   float jresult ;
70145   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70146   float result;
70147
70148   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70149   {
70150     try {
70151       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70152     } catch (std::out_of_range& e) {
70153       {
70154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70155       };
70156     } catch (std::exception& e) {
70157       {
70158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70159       };
70160     } catch (Dali::DaliException e) {
70161       {
70162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70163       };
70164     } catch (...) {
70165       {
70166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70167       };
70168     }
70169   }
70170
70171   jresult = result;
70172   return jresult;
70173 }
70174
70175
70176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70177   float jresult ;
70178   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70179   float result;
70180
70181   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70182   {
70183     try {
70184       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
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 (Dali::DaliException e) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70196       };
70197     } catch (...) {
70198       {
70199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70200       };
70201     }
70202   }
70203
70204   jresult = result;
70205   return jresult;
70206 }
70207
70208
70209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70210   int jresult ;
70211   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70212   int arg2 ;
70213   int arg3 ;
70214   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70215   bool arg5 ;
70216   int result;
70217
70218   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70219   arg2 = (int)jarg2;
70220   arg3 = (int)jarg3;
70221   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70222   arg5 = jarg5 ? true : false;
70223   {
70224     try {
70225       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70226     } catch (std::out_of_range& e) {
70227       {
70228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70229       };
70230     } catch (std::exception& e) {
70231       {
70232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70233       };
70234     } catch (Dali::DaliException e) {
70235       {
70236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70237       };
70238     } catch (...) {
70239       {
70240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70241       };
70242     }
70243   }
70244
70245   jresult = result;
70246   return jresult;
70247 }
70248
70249
70250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70251   float jresult ;
70252   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70253   float result;
70254
70255   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70256   {
70257     try {
70258       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70259     } catch (std::out_of_range& e) {
70260       {
70261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70262       };
70263     } catch (std::exception& e) {
70264       {
70265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70266       };
70267     } catch (Dali::DaliException e) {
70268       {
70269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70270       };
70271     } catch (...) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70274       };
70275     }
70276   }
70277
70278   jresult = result;
70279   return jresult;
70280 }
70281
70282
70283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70284   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70285   Dali::Actor *arg2 = 0 ;
70286   int arg3 ;
70287   Dali::Vector3 *arg4 = 0 ;
70288   Dali::Actor *arg5 = 0 ;
70289
70290   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70291   arg2 = (Dali::Actor *)jarg2;
70292   if (!arg2) {
70293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70294     return ;
70295   }
70296   arg3 = (int)jarg3;
70297   arg4 = (Dali::Vector3 *)jarg4;
70298   if (!arg4) {
70299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70300     return ;
70301   }
70302   arg5 = (Dali::Actor *)jarg5;
70303   if (!arg5) {
70304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70305     return ;
70306   }
70307   {
70308     try {
70309       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70310     } catch (std::out_of_range& e) {
70311       {
70312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70313       };
70314     } catch (std::exception& e) {
70315       {
70316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70317       };
70318     } catch (Dali::DaliException e) {
70319       {
70320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70321       };
70322     } catch (...) {
70323       {
70324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70325       };
70326     }
70327   }
70328
70329 }
70330
70331
70332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70333   void * jresult ;
70334   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70335   int arg2 ;
70336   float arg3 ;
70337   Dali::Vector3 *arg4 = 0 ;
70338   Dali::Vector3 result;
70339
70340   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70341   arg2 = (int)jarg2;
70342   arg3 = (float)jarg3;
70343   arg4 = (Dali::Vector3 *)jarg4;
70344   if (!arg4) {
70345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70346     return 0;
70347   }
70348   {
70349     try {
70350       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70351     } catch (std::out_of_range& e) {
70352       {
70353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70354       };
70355     } catch (std::exception& e) {
70356       {
70357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70358       };
70359     } catch (Dali::DaliException e) {
70360       {
70361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70362       };
70363     } catch (...) {
70364       {
70365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70366       };
70367     }
70368   }
70369
70370   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70371   return jresult;
70372 }
70373
70374
70375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70376   void * jresult ;
70377   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70378   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70379
70380   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70381   {
70382     try {
70383       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70384     } catch (std::out_of_range& e) {
70385       {
70386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70387       };
70388     } catch (std::exception& e) {
70389       {
70390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70391       };
70392     } catch (Dali::DaliException e) {
70393       {
70394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70395       };
70396     } catch (...) {
70397       {
70398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70399       };
70400     }
70401   }
70402
70403   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70404   return jresult;
70405 }
70406
70407
70408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70409   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70410
70411   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70412   {
70413     try {
70414       delete arg1;
70415     } catch (std::out_of_range& e) {
70416       {
70417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70418       };
70419     } catch (std::exception& e) {
70420       {
70421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70422       };
70423     } catch (Dali::DaliException e) {
70424       {
70425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70426       };
70427     } catch (...) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70430       };
70431     }
70432   }
70433
70434 }
70435
70436
70437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70438   unsigned int jresult ;
70439   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70440   unsigned int result;
70441
70442   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70443   {
70444     try {
70445       result = (unsigned int)(arg1)->GetNumberOfItems();
70446     } catch (std::out_of_range& e) {
70447       {
70448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70449       };
70450     } catch (std::exception& e) {
70451       {
70452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70453       };
70454     } catch (Dali::DaliException e) {
70455       {
70456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70457       };
70458     } catch (...) {
70459       {
70460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70461       };
70462     }
70463   }
70464
70465   jresult = result;
70466   return jresult;
70467 }
70468
70469
70470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70471   void * jresult ;
70472   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70473   unsigned int arg2 ;
70474   Dali::Actor result;
70475
70476   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70477   arg2 = (unsigned int)jarg2;
70478   {
70479     try {
70480       result = (arg1)->NewItem(arg2);
70481     } catch (std::out_of_range& e) {
70482       {
70483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70484       };
70485     } catch (std::exception& e) {
70486       {
70487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70488       };
70489     } catch (Dali::DaliException e) {
70490       {
70491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70492       };
70493     } catch (...) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70496       };
70497     }
70498   }
70499
70500   jresult = new Dali::Actor((const Dali::Actor &)result);
70501   return jresult;
70502 }
70503
70504
70505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70506   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70507   unsigned int arg2 ;
70508   Dali::Actor arg3 ;
70509   Dali::Actor *argp3 ;
70510
70511   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70512   arg2 = (unsigned int)jarg2;
70513   argp3 = (Dali::Actor *)jarg3;
70514   if (!argp3) {
70515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70516     return ;
70517   }
70518   arg3 = *argp3;
70519   {
70520     try {
70521       (arg1)->ItemReleased(arg2,arg3);
70522     } catch (std::out_of_range& e) {
70523       {
70524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70525       };
70526     } catch (std::exception& e) {
70527       {
70528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70529       };
70530     } catch (Dali::DaliException e) {
70531       {
70532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70533       };
70534     } catch (...) {
70535       {
70536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70537       };
70538     }
70539   }
70540
70541 }
70542
70543
70544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70545   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70546   unsigned int arg2 ;
70547   Dali::Actor arg3 ;
70548   Dali::Actor *argp3 ;
70549
70550   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70551   arg2 = (unsigned int)jarg2;
70552   argp3 = (Dali::Actor *)jarg3;
70553   if (!argp3) {
70554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70555     return ;
70556   }
70557   arg3 = *argp3;
70558   {
70559     try {
70560       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70561     } catch (std::out_of_range& e) {
70562       {
70563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70564       };
70565     } catch (std::exception& e) {
70566       {
70567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (Dali::DaliException e) {
70570       {
70571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70572       };
70573     } catch (...) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70576       };
70577     }
70578   }
70579
70580 }
70581
70582
70583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70584   void * jresult ;
70585   Dali::Toolkit::ItemFactory *result = 0 ;
70586
70587   {
70588     try {
70589       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70605       };
70606     }
70607   }
70608
70609   jresult = (void *)result;
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) {
70615   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70616   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70617   if (director) {
70618     director->swig_connect_director(callback0, callback1, callback2);
70619   }
70620 }
70621
70622
70623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70624   int jresult ;
70625   int result;
70626
70627   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70628   jresult = (int)result;
70629   return jresult;
70630 }
70631
70632
70633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70634   int jresult ;
70635   int result;
70636
70637   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70638   jresult = (int)result;
70639   return jresult;
70640 }
70641
70642
70643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70644   int jresult ;
70645   int result;
70646
70647   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70648   jresult = (int)result;
70649   return jresult;
70650 }
70651
70652
70653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70654   int jresult ;
70655   int result;
70656
70657   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70658   jresult = (int)result;
70659   return jresult;
70660 }
70661
70662
70663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70664   int jresult ;
70665   int result;
70666
70667   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70668   jresult = (int)result;
70669   return jresult;
70670 }
70671
70672
70673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70674   int jresult ;
70675   int result;
70676
70677   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70678   jresult = (int)result;
70679   return jresult;
70680 }
70681
70682
70683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70684   int jresult ;
70685   int result;
70686
70687   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70688   jresult = (int)result;
70689   return jresult;
70690 }
70691
70692
70693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70694   int jresult ;
70695   int result;
70696
70697   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70698   jresult = (int)result;
70699   return jresult;
70700 }
70701
70702
70703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70704   int jresult ;
70705   int result;
70706
70707   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70708   jresult = (int)result;
70709   return jresult;
70710 }
70711
70712
70713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70714   int jresult ;
70715   int result;
70716
70717   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70718   jresult = (int)result;
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70724   int jresult ;
70725   int result;
70726
70727   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70728   jresult = (int)result;
70729   return jresult;
70730 }
70731
70732
70733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70734   void * jresult ;
70735   Dali::Toolkit::ItemView::Property *result = 0 ;
70736
70737   {
70738     try {
70739       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70740     } catch (std::out_of_range& e) {
70741       {
70742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70743       };
70744     } catch (std::exception& e) {
70745       {
70746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70747       };
70748     } catch (Dali::DaliException e) {
70749       {
70750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70751       };
70752     } catch (...) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70755       };
70756     }
70757   }
70758
70759   jresult = (void *)result;
70760   return jresult;
70761 }
70762
70763
70764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70765   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70766
70767   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70768   {
70769     try {
70770       delete arg1;
70771     } catch (std::out_of_range& e) {
70772       {
70773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70774       };
70775     } catch (std::exception& e) {
70776       {
70777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70778       };
70779     } catch (Dali::DaliException e) {
70780       {
70781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70782       };
70783     } catch (...) {
70784       {
70785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70786       };
70787     }
70788   }
70789
70790 }
70791
70792
70793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70794   void * jresult ;
70795   Dali::Toolkit::ItemView *result = 0 ;
70796
70797   {
70798     try {
70799       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70807       };
70808     } catch (Dali::DaliException e) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70815       };
70816     }
70817   }
70818
70819   jresult = (void *)result;
70820   return jresult;
70821 }
70822
70823
70824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70825   void * jresult ;
70826   Dali::Toolkit::ItemView *arg1 = 0 ;
70827   Dali::Toolkit::ItemView *result = 0 ;
70828
70829   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70830   if (!arg1) {
70831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70832     return 0;
70833   }
70834   {
70835     try {
70836       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70837     } catch (std::out_of_range& e) {
70838       {
70839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70840       };
70841     } catch (std::exception& e) {
70842       {
70843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70844       };
70845     } catch (Dali::DaliException e) {
70846       {
70847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70848       };
70849     } catch (...) {
70850       {
70851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70852       };
70853     }
70854   }
70855
70856   jresult = (void *)result;
70857   return jresult;
70858 }
70859
70860
70861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70862   void * jresult ;
70863   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70864   Dali::Toolkit::ItemView *arg2 = 0 ;
70865   Dali::Toolkit::ItemView *result = 0 ;
70866
70867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70868   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70869   if (!arg2) {
70870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70871     return 0;
70872   }
70873   {
70874     try {
70875       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70876     } catch (std::out_of_range& e) {
70877       {
70878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70879       };
70880     } catch (std::exception& e) {
70881       {
70882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70883       };
70884     } catch (Dali::DaliException e) {
70885       {
70886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70887       };
70888     } catch (...) {
70889       {
70890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70891       };
70892     }
70893   }
70894
70895   jresult = (void *)result;
70896   return jresult;
70897 }
70898
70899
70900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70902
70903   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70904   {
70905     try {
70906       delete arg1;
70907     } catch (std::out_of_range& e) {
70908       {
70909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70910       };
70911     } catch (std::exception& e) {
70912       {
70913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70914       };
70915     } catch (Dali::DaliException e) {
70916       {
70917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70918       };
70919     } catch (...) {
70920       {
70921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70922       };
70923     }
70924   }
70925
70926 }
70927
70928
70929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70930   void * jresult ;
70931   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70932   Dali::Toolkit::ItemView result;
70933
70934   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70935   if (!arg1) {
70936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70937     return 0;
70938   }
70939   {
70940     try {
70941       result = Dali::Toolkit::ItemView::New(*arg1);
70942     } catch (std::out_of_range& e) {
70943       {
70944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70945       };
70946     } catch (std::exception& e) {
70947       {
70948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70949       };
70950     } catch (Dali::DaliException e) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70953       };
70954     } catch (...) {
70955       {
70956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70957       };
70958     }
70959   }
70960
70961   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70962   return jresult;
70963 }
70964
70965
70966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70967   void * jresult ;
70968   Dali::BaseHandle arg1 ;
70969   Dali::BaseHandle *argp1 ;
70970   Dali::Toolkit::ItemView result;
70971
70972   argp1 = (Dali::BaseHandle *)jarg1;
70973   if (!argp1) {
70974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70975     return 0;
70976   }
70977   arg1 = *argp1;
70978   {
70979     try {
70980       result = Dali::Toolkit::ItemView::DownCast(arg1);
70981     } catch (std::out_of_range& e) {
70982       {
70983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70984       };
70985     } catch (std::exception& e) {
70986       {
70987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70988       };
70989     } catch (Dali::DaliException e) {
70990       {
70991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70992       };
70993     } catch (...) {
70994       {
70995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70996       };
70997     }
70998   }
70999
71000   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71001   return jresult;
71002 }
71003
71004
71005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71006   unsigned int jresult ;
71007   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71008   unsigned int result;
71009
71010   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71011   {
71012     try {
71013       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71014     } catch (std::out_of_range& e) {
71015       {
71016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (std::exception& e) {
71019       {
71020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (Dali::DaliException e) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71025       };
71026     } catch (...) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71029       };
71030     }
71031   }
71032
71033   jresult = result;
71034   return jresult;
71035 }
71036
71037
71038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71039   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71040   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71041
71042   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71043   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71044   if (!arg2) {
71045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71046     return ;
71047   }
71048   {
71049     try {
71050       (arg1)->AddLayout(*arg2);
71051     } catch (std::out_of_range& e) {
71052       {
71053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71054       };
71055     } catch (std::exception& e) {
71056       {
71057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71058       };
71059     } catch (Dali::DaliException e) {
71060       {
71061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71062       };
71063     } catch (...) {
71064       {
71065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71066       };
71067     }
71068   }
71069
71070 }
71071
71072
71073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71075   unsigned int arg2 ;
71076
71077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71078   arg2 = (unsigned int)jarg2;
71079   {
71080     try {
71081       (arg1)->RemoveLayout(arg2);
71082     } catch (std::out_of_range& e) {
71083       {
71084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71085       };
71086     } catch (std::exception& e) {
71087       {
71088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71089       };
71090     } catch (Dali::DaliException e) {
71091       {
71092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71093       };
71094     } catch (...) {
71095       {
71096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71097       };
71098     }
71099   }
71100
71101 }
71102
71103
71104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71105   void * jresult ;
71106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71107   unsigned int arg2 ;
71108   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71109
71110   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71111   arg2 = (unsigned int)jarg2;
71112   {
71113     try {
71114       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71115     } catch (std::out_of_range& e) {
71116       {
71117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71118       };
71119     } catch (std::exception& e) {
71120       {
71121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71122       };
71123     } catch (Dali::DaliException e) {
71124       {
71125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71126       };
71127     } catch (...) {
71128       {
71129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71130       };
71131     }
71132   }
71133
71134   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71135   return jresult;
71136 }
71137
71138
71139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71140   void * jresult ;
71141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71142   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71143
71144   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71145   {
71146     try {
71147       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71148     } catch (std::out_of_range& e) {
71149       {
71150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71151       };
71152     } catch (std::exception& e) {
71153       {
71154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71155       };
71156     } catch (Dali::DaliException e) {
71157       {
71158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71159       };
71160     } catch (...) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71163       };
71164     }
71165   }
71166
71167   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71168   return jresult;
71169 }
71170
71171
71172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71173   float jresult ;
71174   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71175   Dali::Toolkit::ItemId arg2 ;
71176   float result;
71177
71178   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71179   arg2 = (Dali::Toolkit::ItemId)jarg2;
71180   {
71181     try {
71182       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71183     } catch (std::out_of_range& e) {
71184       {
71185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71186       };
71187     } catch (std::exception& e) {
71188       {
71189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71190       };
71191     } catch (Dali::DaliException e) {
71192       {
71193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71194       };
71195     } catch (...) {
71196       {
71197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71198       };
71199     }
71200   }
71201
71202   jresult = result;
71203   return jresult;
71204 }
71205
71206
71207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71208   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71209   unsigned int arg2 ;
71210   Dali::Vector3 arg3 ;
71211   float arg4 ;
71212   Dali::Vector3 *argp3 ;
71213
71214   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71215   arg2 = (unsigned int)jarg2;
71216   argp3 = (Dali::Vector3 *)jarg3;
71217   if (!argp3) {
71218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71219     return ;
71220   }
71221   arg3 = *argp3;
71222   arg4 = (float)jarg4;
71223   {
71224     try {
71225       (arg1)->ActivateLayout(arg2,arg3,arg4);
71226     } catch (std::out_of_range& e) {
71227       {
71228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71229       };
71230     } catch (std::exception& e) {
71231       {
71232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71233       };
71234     } catch (Dali::DaliException e) {
71235       {
71236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71237       };
71238     } catch (...) {
71239       {
71240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71241       };
71242     }
71243   }
71244
71245 }
71246
71247
71248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71249   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71250
71251   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71252   {
71253     try {
71254       (arg1)->DeactivateCurrentLayout();
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71262       };
71263     } catch (Dali::DaliException e) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71266       };
71267     } catch (...) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71270       };
71271     }
71272   }
71273
71274 }
71275
71276
71277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71278   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71279   float arg2 ;
71280
71281   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71282   arg2 = (float)jarg2;
71283   {
71284     try {
71285       (arg1)->SetMinimumSwipeSpeed(arg2);
71286     } catch (std::out_of_range& e) {
71287       {
71288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71289       };
71290     } catch (std::exception& e) {
71291       {
71292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71293       };
71294     } catch (Dali::DaliException e) {
71295       {
71296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71297       };
71298     } catch (...) {
71299       {
71300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71301       };
71302     }
71303   }
71304
71305 }
71306
71307
71308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71309   float jresult ;
71310   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71311   float result;
71312
71313   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71314   {
71315     try {
71316       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
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 (Dali::DaliException e) {
71326       {
71327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71328       };
71329     } catch (...) {
71330       {
71331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71332       };
71333     }
71334   }
71335
71336   jresult = result;
71337   return jresult;
71338 }
71339
71340
71341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71343   float arg2 ;
71344
71345   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71346   arg2 = (float)jarg2;
71347   {
71348     try {
71349       (arg1)->SetMinimumSwipeDistance(arg2);
71350     } catch (std::out_of_range& e) {
71351       {
71352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71353       };
71354     } catch (std::exception& e) {
71355       {
71356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71357       };
71358     } catch (Dali::DaliException e) {
71359       {
71360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71361       };
71362     } catch (...) {
71363       {
71364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71365       };
71366     }
71367   }
71368
71369 }
71370
71371
71372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71373   float jresult ;
71374   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71375   float result;
71376
71377   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71378   {
71379     try {
71380       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71381     } catch (std::out_of_range& e) {
71382       {
71383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71384       };
71385     } catch (std::exception& e) {
71386       {
71387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71388       };
71389     } catch (Dali::DaliException e) {
71390       {
71391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71392       };
71393     } catch (...) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71396       };
71397     }
71398   }
71399
71400   jresult = result;
71401   return jresult;
71402 }
71403
71404
71405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71406   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71407   float arg2 ;
71408
71409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71410   arg2 = (float)jarg2;
71411   {
71412     try {
71413       (arg1)->SetWheelScrollDistanceStep(arg2);
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71421       };
71422     } catch (Dali::DaliException e) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71425       };
71426     } catch (...) {
71427       {
71428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71429       };
71430     }
71431   }
71432
71433 }
71434
71435
71436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71437   float jresult ;
71438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71439   float result;
71440
71441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71442   {
71443     try {
71444       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71445     } catch (std::out_of_range& e) {
71446       {
71447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71448       };
71449     } catch (std::exception& e) {
71450       {
71451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71452       };
71453     } catch (Dali::DaliException e) {
71454       {
71455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71460       };
71461     }
71462   }
71463
71464   jresult = result;
71465   return jresult;
71466 }
71467
71468
71469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71470   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71471   bool arg2 ;
71472
71473   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71474   arg2 = jarg2 ? true : false;
71475   {
71476     try {
71477       (arg1)->SetAnchoring(arg2);
71478     } catch (std::out_of_range& e) {
71479       {
71480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71481       };
71482     } catch (std::exception& e) {
71483       {
71484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71485       };
71486     } catch (Dali::DaliException e) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71489       };
71490     } catch (...) {
71491       {
71492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71493       };
71494     }
71495   }
71496
71497 }
71498
71499 //// ========================= end of part 3 =============================
71500
71501 //// ========================== start part 4 ===============================
71502
71503
71504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71505   unsigned int jresult ;
71506   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71507   bool result;
71508
71509   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71510   {
71511     try {
71512       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71513     } catch (std::out_of_range& e) {
71514       {
71515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71516       };
71517     } catch (std::exception& e) {
71518       {
71519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71520       };
71521     } catch (Dali::DaliException e) {
71522       {
71523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71524       };
71525     } catch (...) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71528       };
71529     }
71530   }
71531
71532   jresult = result;
71533   return jresult;
71534 }
71535
71536
71537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71538   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71539   float arg2 ;
71540
71541   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71542   arg2 = (float)jarg2;
71543   {
71544     try {
71545       (arg1)->SetAnchoringDuration(arg2);
71546     } catch (std::out_of_range& e) {
71547       {
71548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71549       };
71550     } catch (std::exception& e) {
71551       {
71552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71553       };
71554     } catch (Dali::DaliException e) {
71555       {
71556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71557       };
71558     } catch (...) {
71559       {
71560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71561       };
71562     }
71563   }
71564
71565 }
71566
71567
71568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71569   float jresult ;
71570   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71571   float result;
71572
71573   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71574   {
71575     try {
71576       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71577     } catch (std::out_of_range& e) {
71578       {
71579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71580       };
71581     } catch (std::exception& e) {
71582       {
71583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71584       };
71585     } catch (Dali::DaliException e) {
71586       {
71587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71588       };
71589     } catch (...) {
71590       {
71591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71592       };
71593     }
71594   }
71595
71596   jresult = result;
71597   return jresult;
71598 }
71599
71600
71601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71602   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71603   Dali::Toolkit::ItemId arg2 ;
71604   float arg3 ;
71605
71606   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71607   arg2 = (Dali::Toolkit::ItemId)jarg2;
71608   arg3 = (float)jarg3;
71609   {
71610     try {
71611       (arg1)->ScrollToItem(arg2,arg3);
71612     } catch (std::out_of_range& e) {
71613       {
71614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71615       };
71616     } catch (std::exception& e) {
71617       {
71618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71619       };
71620     } catch (Dali::DaliException e) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71623       };
71624     } catch (...) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71627       };
71628     }
71629   }
71630
71631 }
71632
71633
71634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71635   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71636   float arg2 ;
71637
71638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71639   arg2 = (float)jarg2;
71640   {
71641     try {
71642       (arg1)->SetRefreshInterval(arg2);
71643     } catch (std::out_of_range& e) {
71644       {
71645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71646       };
71647     } catch (std::exception& e) {
71648       {
71649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71650       };
71651     } catch (Dali::DaliException e) {
71652       {
71653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71654       };
71655     } catch (...) {
71656       {
71657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71658       };
71659     }
71660   }
71661
71662 }
71663
71664
71665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71666   float jresult ;
71667   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71668   float result;
71669
71670   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71671   {
71672     try {
71673       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71674     } catch (std::out_of_range& e) {
71675       {
71676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71677       };
71678     } catch (std::exception& e) {
71679       {
71680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71681       };
71682     } catch (Dali::DaliException e) {
71683       {
71684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71685       };
71686     } catch (...) {
71687       {
71688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71689       };
71690     }
71691   }
71692
71693   jresult = result;
71694   return jresult;
71695 }
71696
71697
71698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71699   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71700
71701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71702   {
71703     try {
71704       (arg1)->Refresh();
71705     } catch (std::out_of_range& e) {
71706       {
71707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71708       };
71709     } catch (std::exception& e) {
71710       {
71711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71712       };
71713     } catch (Dali::DaliException e) {
71714       {
71715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71716       };
71717     } catch (...) {
71718       {
71719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71720       };
71721     }
71722   }
71723
71724 }
71725
71726
71727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71728   void * jresult ;
71729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71730   Dali::Toolkit::ItemId arg2 ;
71731   Dali::Actor result;
71732
71733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71734   arg2 = (Dali::Toolkit::ItemId)jarg2;
71735   {
71736     try {
71737       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71738     } catch (std::out_of_range& e) {
71739       {
71740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71741       };
71742     } catch (std::exception& e) {
71743       {
71744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71745       };
71746     } catch (Dali::DaliException e) {
71747       {
71748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71749       };
71750     } catch (...) {
71751       {
71752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71753       };
71754     }
71755   }
71756
71757   jresult = new Dali::Actor((const Dali::Actor &)result);
71758   return jresult;
71759 }
71760
71761
71762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71763   unsigned int jresult ;
71764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71765   Dali::Actor arg2 ;
71766   Dali::Actor *argp2 ;
71767   Dali::Toolkit::ItemId result;
71768
71769   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71770   argp2 = (Dali::Actor *)jarg2;
71771   if (!argp2) {
71772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71773     return 0;
71774   }
71775   arg2 = *argp2;
71776   {
71777     try {
71778       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71779     } catch (std::out_of_range& e) {
71780       {
71781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71782       };
71783     } catch (std::exception& e) {
71784       {
71785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71786       };
71787     } catch (Dali::DaliException e) {
71788       {
71789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71790       };
71791     } catch (...) {
71792       {
71793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71794       };
71795     }
71796   }
71797
71798   jresult = result;
71799   return jresult;
71800 }
71801
71802
71803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71804   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71805   Dali::Toolkit::Item arg2 ;
71806   float arg3 ;
71807   Dali::Toolkit::Item *argp2 ;
71808
71809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71810   argp2 = (Dali::Toolkit::Item *)jarg2;
71811   if (!argp2) {
71812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71813     return ;
71814   }
71815   arg2 = *argp2;
71816   arg3 = (float)jarg3;
71817   {
71818     try {
71819       (arg1)->InsertItem(arg2,arg3);
71820     } catch (std::out_of_range& e) {
71821       {
71822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71823       };
71824     } catch (std::exception& e) {
71825       {
71826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71827       };
71828     } catch (Dali::DaliException e) {
71829       {
71830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71835       };
71836     }
71837   }
71838
71839 }
71840
71841
71842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71844   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71845   float arg3 ;
71846
71847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71848   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71849   if (!arg2) {
71850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71851     return ;
71852   }
71853   arg3 = (float)jarg3;
71854   {
71855     try {
71856       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71857     } catch (std::out_of_range& e) {
71858       {
71859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (std::exception& e) {
71862       {
71863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71864       };
71865     } catch (Dali::DaliException e) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71868       };
71869     } catch (...) {
71870       {
71871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71872       };
71873     }
71874   }
71875
71876 }
71877
71878
71879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71880   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71881   Dali::Toolkit::ItemId arg2 ;
71882   float arg3 ;
71883
71884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71885   arg2 = (Dali::Toolkit::ItemId)jarg2;
71886   arg3 = (float)jarg3;
71887   {
71888     try {
71889       (arg1)->RemoveItem(arg2,arg3);
71890     } catch (std::out_of_range& e) {
71891       {
71892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71893       };
71894     } catch (std::exception& e) {
71895       {
71896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71897       };
71898     } catch (Dali::DaliException e) {
71899       {
71900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71901       };
71902     } catch (...) {
71903       {
71904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71905       };
71906     }
71907   }
71908
71909 }
71910
71911
71912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71913   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71914   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71915   float arg3 ;
71916
71917   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71918   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71919   if (!arg2) {
71920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71921     return ;
71922   }
71923   arg3 = (float)jarg3;
71924   {
71925     try {
71926       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71927     } catch (std::out_of_range& e) {
71928       {
71929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71930       };
71931     } catch (std::exception& e) {
71932       {
71933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71934       };
71935     } catch (Dali::DaliException e) {
71936       {
71937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71938       };
71939     } catch (...) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71942       };
71943     }
71944   }
71945
71946 }
71947
71948
71949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71950   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71951   Dali::Toolkit::Item arg2 ;
71952   float arg3 ;
71953   Dali::Toolkit::Item *argp2 ;
71954
71955   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71956   argp2 = (Dali::Toolkit::Item *)jarg2;
71957   if (!argp2) {
71958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71959     return ;
71960   }
71961   arg2 = *argp2;
71962   arg3 = (float)jarg3;
71963   {
71964     try {
71965       (arg1)->ReplaceItem(arg2,arg3);
71966     } catch (std::out_of_range& e) {
71967       {
71968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71969       };
71970     } catch (std::exception& e) {
71971       {
71972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71973       };
71974     } catch (Dali::DaliException e) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71977       };
71978     } catch (...) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71981       };
71982     }
71983   }
71984
71985 }
71986
71987
71988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71990   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71991   float arg3 ;
71992
71993   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71994   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71995   if (!arg2) {
71996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71997     return ;
71998   }
71999   arg3 = (float)jarg3;
72000   {
72001     try {
72002       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72003     } catch (std::out_of_range& e) {
72004       {
72005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72006       };
72007     } catch (std::exception& e) {
72008       {
72009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72010       };
72011     } catch (Dali::DaliException e) {
72012       {
72013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72018       };
72019     }
72020   }
72021
72022 }
72023
72024
72025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
72026   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72027   Dali::Vector3 *arg2 = 0 ;
72028
72029   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72030   arg2 = (Dali::Vector3 *)jarg2;
72031   if (!arg2) {
72032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72033     return ;
72034   }
72035   {
72036     try {
72037       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
72038     } catch (std::out_of_range& e) {
72039       {
72040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72041       };
72042     } catch (std::exception& e) {
72043       {
72044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72045       };
72046     } catch (Dali::DaliException e) {
72047       {
72048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72049       };
72050     } catch (...) {
72051       {
72052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72053       };
72054     }
72055   }
72056
72057 }
72058
72059
72060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
72061   void * jresult ;
72062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72063   Dali::Vector3 result;
72064
72065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72066   {
72067     try {
72068       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
72069     } catch (std::out_of_range& e) {
72070       {
72071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72072       };
72073     } catch (std::exception& e) {
72074       {
72075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72076       };
72077     } catch (Dali::DaliException e) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72084       };
72085     }
72086   }
72087
72088   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72089   return jresult;
72090 }
72091
72092
72093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
72094   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72095   Dali::Vector3 *arg2 = 0 ;
72096
72097   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72098   arg2 = (Dali::Vector3 *)jarg2;
72099   if (!arg2) {
72100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72101     return ;
72102   }
72103   {
72104     try {
72105       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
72106     } catch (std::out_of_range& e) {
72107       {
72108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72109       };
72110     } catch (std::exception& e) {
72111       {
72112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72113       };
72114     } catch (Dali::DaliException e) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72117       };
72118     } catch (...) {
72119       {
72120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72121       };
72122     }
72123   }
72124
72125 }
72126
72127
72128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72129   void * jresult ;
72130   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72131   Dali::Vector3 result;
72132
72133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72134   {
72135     try {
72136       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (Dali::DaliException e) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72148       };
72149     } catch (...) {
72150       {
72151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72152       };
72153     }
72154   }
72155
72156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72157   return jresult;
72158 }
72159
72160
72161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72162   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72163   Dali::Toolkit::ItemRange *arg2 = 0 ;
72164
72165   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72166   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72167   if (!arg2) {
72168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72169     return ;
72170   }
72171   {
72172     try {
72173       (arg1)->GetItemsRange(*arg2);
72174     } catch (std::out_of_range& e) {
72175       {
72176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72177       };
72178     } catch (std::exception& e) {
72179       {
72180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72181       };
72182     } catch (Dali::DaliException e) {
72183       {
72184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72185       };
72186     } catch (...) {
72187       {
72188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72189       };
72190     }
72191   }
72192
72193 }
72194
72195
72196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72197   void * jresult ;
72198   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72199   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72200
72201   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72202   {
72203     try {
72204       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72205     } catch (std::out_of_range& e) {
72206       {
72207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72208       };
72209     } catch (std::exception& e) {
72210       {
72211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72212       };
72213     } catch (Dali::DaliException e) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72216       };
72217     } catch (...) {
72218       {
72219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72220       };
72221     }
72222   }
72223
72224   jresult = (void *)result;
72225   return jresult;
72226 }
72227
72228
72229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72230   Dali::Vector3 *arg1 = 0 ;
72231   PropertyInputContainer *arg2 = 0 ;
72232
72233   arg1 = (Dali::Vector3 *)jarg1;
72234   if (!arg1) {
72235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72236     return ;
72237   }
72238   arg2 = (PropertyInputContainer *)jarg2;
72239   if (!arg2) {
72240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72241     return ;
72242   }
72243   {
72244     try {
72245       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72246     } catch (std::out_of_range& e) {
72247       {
72248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72249       };
72250     } catch (std::exception& e) {
72251       {
72252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72253       };
72254     } catch (Dali::DaliException e) {
72255       {
72256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72257       };
72258     } catch (...) {
72259       {
72260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72261       };
72262     }
72263   }
72264
72265 }
72266
72267
72268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72269   Dali::Vector3 *arg1 = 0 ;
72270   PropertyInputContainer *arg2 = 0 ;
72271
72272   arg1 = (Dali::Vector3 *)jarg1;
72273   if (!arg1) {
72274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72275     return ;
72276   }
72277   arg2 = (PropertyInputContainer *)jarg2;
72278   if (!arg2) {
72279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72280     return ;
72281   }
72282   {
72283     try {
72284       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (Dali::DaliException e) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72300       };
72301     }
72302   }
72303
72304 }
72305
72306
72307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72308   void * jresult ;
72309   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72310
72311   {
72312     try {
72313       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72314     } catch (std::out_of_range& e) {
72315       {
72316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72317       };
72318     } catch (std::exception& e) {
72319       {
72320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72321       };
72322     } catch (Dali::DaliException e) {
72323       {
72324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72325       };
72326     } catch (...) {
72327       {
72328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72329       };
72330     }
72331   }
72332
72333   jresult = (void *)result;
72334   return jresult;
72335 }
72336
72337
72338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72339   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72340
72341   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72342   {
72343     try {
72344       delete arg1;
72345     } catch (std::out_of_range& e) {
72346       {
72347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72348       };
72349     } catch (std::exception& e) {
72350       {
72351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72352       };
72353     } catch (Dali::DaliException e) {
72354       {
72355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72356       };
72357     } catch (...) {
72358       {
72359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72360       };
72361     }
72362   }
72363
72364 }
72365
72366
72367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72368   void * jresult ;
72369   Dali::Path arg1 ;
72370   Dali::Vector3 *arg2 = 0 ;
72371   Dali::Property::Index arg3 ;
72372   Dali::Vector3 *arg4 = 0 ;
72373   unsigned int arg5 ;
72374   Dali::Path *argp1 ;
72375   Dali::Toolkit::ScrollViewPagePathEffect result;
72376
72377   argp1 = (Dali::Path *)jarg1;
72378   if (!argp1) {
72379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72380     return 0;
72381   }
72382   arg1 = *argp1;
72383   arg2 = (Dali::Vector3 *)jarg2;
72384   if (!arg2) {
72385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72386     return 0;
72387   }
72388   arg3 = (Dali::Property::Index)jarg3;
72389   arg4 = (Dali::Vector3 *)jarg4;
72390   if (!arg4) {
72391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72392     return 0;
72393   }
72394   arg5 = (unsigned int)jarg5;
72395   {
72396     try {
72397       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72398     } catch (std::out_of_range& e) {
72399       {
72400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72401       };
72402     } catch (std::exception& e) {
72403       {
72404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72405       };
72406     } catch (Dali::DaliException e) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72409       };
72410     } catch (...) {
72411       {
72412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72413       };
72414     }
72415   }
72416
72417   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72418   return jresult;
72419 }
72420
72421
72422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72423   void * jresult ;
72424   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72425
72426   {
72427     try {
72428       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (Dali::DaliException e) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72440       };
72441     } catch (...) {
72442       {
72443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72444       };
72445     }
72446   }
72447
72448   jresult = (void *)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72454   void * jresult ;
72455   Dali::BaseHandle arg1 ;
72456   Dali::BaseHandle *argp1 ;
72457   Dali::Toolkit::ScrollViewPagePathEffect result;
72458
72459   argp1 = (Dali::BaseHandle *)jarg1;
72460   if (!argp1) {
72461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72462     return 0;
72463   }
72464   arg1 = *argp1;
72465   {
72466     try {
72467       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72468     } catch (std::out_of_range& e) {
72469       {
72470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72471       };
72472     } catch (std::exception& e) {
72473       {
72474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72475       };
72476     } catch (Dali::DaliException e) {
72477       {
72478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72479       };
72480     } catch (...) {
72481       {
72482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72483       };
72484     }
72485   }
72486
72487   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72488   return jresult;
72489 }
72490
72491
72492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72493   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72494   Dali::Actor arg2 ;
72495   unsigned int arg3 ;
72496   Dali::Actor *argp2 ;
72497
72498   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72499   argp2 = (Dali::Actor *)jarg2;
72500   if (!argp2) {
72501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72502     return ;
72503   }
72504   arg2 = *argp2;
72505   arg3 = (unsigned int)jarg3;
72506   {
72507     try {
72508       (arg1)->ApplyToPage(arg2,arg3);
72509     } catch (std::out_of_range& e) {
72510       {
72511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72512       };
72513     } catch (std::exception& e) {
72514       {
72515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72516       };
72517     } catch (Dali::DaliException e) {
72518       {
72519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72520       };
72521     } catch (...) {
72522       {
72523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72524       };
72525     }
72526   }
72527
72528 }
72529
72530
72531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72532   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72533
72534   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72535   {
72536     try {
72537       delete arg1;
72538     } catch (std::out_of_range& e) {
72539       {
72540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72541       };
72542     } catch (std::exception& e) {
72543       {
72544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72545       };
72546     } catch (Dali::DaliException e) {
72547       {
72548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72549       };
72550     } catch (...) {
72551       {
72552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72553       };
72554     }
72555   }
72556
72557 }
72558
72559
72560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72561   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72562   Dali::Toolkit::ClampState arg2 ;
72563
72564   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72565   arg2 = (Dali::Toolkit::ClampState)jarg2;
72566   if (arg1) (arg1)->x = arg2;
72567 }
72568
72569
72570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72571   int jresult ;
72572   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72573   Dali::Toolkit::ClampState result;
72574
72575   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72576   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72577   jresult = (int)result;
72578   return jresult;
72579 }
72580
72581
72582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72583   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72584   Dali::Toolkit::ClampState arg2 ;
72585
72586   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72587   arg2 = (Dali::Toolkit::ClampState)jarg2;
72588   if (arg1) (arg1)->y = arg2;
72589 }
72590
72591
72592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72593   int jresult ;
72594   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72595   Dali::Toolkit::ClampState result;
72596
72597   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72598   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72599   jresult = (int)result;
72600   return jresult;
72601 }
72602
72603
72604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72605   void * jresult ;
72606   Dali::Toolkit::ClampState2D *result = 0 ;
72607
72608   {
72609     try {
72610       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72611     } catch (std::out_of_range& e) {
72612       {
72613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72614       };
72615     } catch (std::exception& e) {
72616       {
72617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72618       };
72619     } catch (Dali::DaliException e) {
72620       {
72621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72622       };
72623     } catch (...) {
72624       {
72625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72626       };
72627     }
72628   }
72629
72630   jresult = (void *)result;
72631   return jresult;
72632 }
72633
72634
72635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72636   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72637
72638   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72639   {
72640     try {
72641       delete arg1;
72642     } catch (std::out_of_range& e) {
72643       {
72644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72645       };
72646     } catch (std::exception& e) {
72647       {
72648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72649       };
72650     } catch (Dali::DaliException e) {
72651       {
72652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72653       };
72654     } catch (...) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72657       };
72658     }
72659   }
72660
72661 }
72662
72663
72664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72665   void * jresult ;
72666   float arg1 ;
72667   float arg2 ;
72668   bool arg3 ;
72669   Dali::Toolkit::RulerDomain *result = 0 ;
72670
72671   arg1 = (float)jarg1;
72672   arg2 = (float)jarg2;
72673   arg3 = jarg3 ? true : false;
72674   {
72675     try {
72676       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72677     } catch (std::out_of_range& e) {
72678       {
72679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72680       };
72681     } catch (std::exception& e) {
72682       {
72683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72684       };
72685     } catch (Dali::DaliException e) {
72686       {
72687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72688       };
72689     } catch (...) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72692       };
72693     }
72694   }
72695
72696   jresult = (void *)result;
72697   return jresult;
72698 }
72699
72700
72701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72702   void * jresult ;
72703   float arg1 ;
72704   float arg2 ;
72705   Dali::Toolkit::RulerDomain *result = 0 ;
72706
72707   arg1 = (float)jarg1;
72708   arg2 = (float)jarg2;
72709   {
72710     try {
72711       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72712     } catch (std::out_of_range& e) {
72713       {
72714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72715       };
72716     } catch (std::exception& e) {
72717       {
72718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (Dali::DaliException e) {
72721       {
72722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72727       };
72728     }
72729   }
72730
72731   jresult = (void *)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72737   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72738   float arg2 ;
72739
72740   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72741   arg2 = (float)jarg2;
72742   if (arg1) (arg1)->min = arg2;
72743 }
72744
72745
72746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72747   float jresult ;
72748   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72749   float result;
72750
72751   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72752   result = (float) ((arg1)->min);
72753   jresult = result;
72754   return jresult;
72755 }
72756
72757
72758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72759   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72760   float arg2 ;
72761
72762   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72763   arg2 = (float)jarg2;
72764   if (arg1) (arg1)->max = arg2;
72765 }
72766
72767
72768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72769   float jresult ;
72770   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72771   float result;
72772
72773   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72774   result = (float) ((arg1)->max);
72775   jresult = result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72781   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72782   bool arg2 ;
72783
72784   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72785   arg2 = jarg2 ? true : false;
72786   if (arg1) (arg1)->enabled = arg2;
72787 }
72788
72789
72790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72791   unsigned int jresult ;
72792   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72793   bool result;
72794
72795   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72796   result = (bool) ((arg1)->enabled);
72797   jresult = result;
72798   return jresult;
72799 }
72800
72801
72802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72803   float jresult ;
72804   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72805   float arg2 ;
72806   float arg3 ;
72807   float arg4 ;
72808   float result;
72809
72810   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72811   arg2 = (float)jarg2;
72812   arg3 = (float)jarg3;
72813   arg4 = (float)jarg4;
72814   {
72815     try {
72816       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72817     } catch (std::out_of_range& e) {
72818       {
72819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72820       };
72821     } catch (std::exception& e) {
72822       {
72823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72824       };
72825     } catch (Dali::DaliException e) {
72826       {
72827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72828       };
72829     } catch (...) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72832       };
72833     }
72834   }
72835
72836   jresult = result;
72837   return jresult;
72838 }
72839
72840
72841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72842   float jresult ;
72843   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72844   float arg2 ;
72845   float arg3 ;
72846   float result;
72847
72848   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72849   arg2 = (float)jarg2;
72850   arg3 = (float)jarg3;
72851   {
72852     try {
72853       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72854     } catch (std::out_of_range& e) {
72855       {
72856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72857       };
72858     } catch (std::exception& e) {
72859       {
72860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72861       };
72862     } catch (Dali::DaliException e) {
72863       {
72864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72865       };
72866     } catch (...) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72869       };
72870     }
72871   }
72872
72873   jresult = result;
72874   return jresult;
72875 }
72876
72877
72878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72879   float jresult ;
72880   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72881   float arg2 ;
72882   float result;
72883
72884   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72885   arg2 = (float)jarg2;
72886   {
72887     try {
72888       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72889     } catch (std::out_of_range& e) {
72890       {
72891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72892       };
72893     } catch (std::exception& e) {
72894       {
72895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (Dali::DaliException e) {
72898       {
72899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72900       };
72901     } catch (...) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72904       };
72905     }
72906   }
72907
72908   jresult = result;
72909   return jresult;
72910 }
72911
72912
72913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72914   float jresult ;
72915   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72916   float arg2 ;
72917   float arg3 ;
72918   float arg4 ;
72919   Dali::Toolkit::ClampState *arg5 = 0 ;
72920   float result;
72921
72922   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72923   arg2 = (float)jarg2;
72924   arg3 = (float)jarg3;
72925   arg4 = (float)jarg4;
72926   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72927   if (!arg5) {
72928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72929     return 0;
72930   }
72931   {
72932     try {
72933       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72934     } catch (std::out_of_range& e) {
72935       {
72936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72937       };
72938     } catch (std::exception& e) {
72939       {
72940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72941       };
72942     } catch (Dali::DaliException e) {
72943       {
72944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72945       };
72946     } catch (...) {
72947       {
72948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72949       };
72950     }
72951   }
72952
72953   jresult = result;
72954   return jresult;
72955 }
72956
72957
72958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72959   float jresult ;
72960   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72961   float result;
72962
72963   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72964   {
72965     try {
72966       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (Dali::DaliException e) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72982       };
72983     }
72984   }
72985
72986   jresult = result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72992   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72993
72994   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72995   {
72996     try {
72997       delete arg1;
72998     } catch (std::out_of_range& e) {
72999       {
73000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73001       };
73002     } catch (std::exception& e) {
73003       {
73004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73005       };
73006     } catch (Dali::DaliException e) {
73007       {
73008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73009       };
73010     } catch (...) {
73011       {
73012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73013       };
73014     }
73015   }
73016
73017 }
73018
73019
73020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
73021   float jresult ;
73022   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73023   float arg2 ;
73024   float arg3 ;
73025   float result;
73026
73027   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73028   arg2 = (float)jarg2;
73029   arg3 = (float)jarg3;
73030   {
73031     try {
73032       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
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 (Dali::DaliException e) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73044       };
73045     } catch (...) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73048       };
73049     }
73050   }
73051
73052   jresult = result;
73053   return jresult;
73054 }
73055
73056
73057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
73058   float jresult ;
73059   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73060   float arg2 ;
73061   float result;
73062
73063   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73064   arg2 = (float)jarg2;
73065   {
73066     try {
73067       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
73068     } catch (std::out_of_range& e) {
73069       {
73070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73071       };
73072     } catch (std::exception& e) {
73073       {
73074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73075       };
73076     } catch (Dali::DaliException e) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73079       };
73080     } catch (...) {
73081       {
73082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73083       };
73084     }
73085   }
73086
73087   jresult = result;
73088   return jresult;
73089 }
73090
73091
73092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73093   float jresult ;
73094   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73095   unsigned int arg2 ;
73096   unsigned int *arg3 = 0 ;
73097   bool arg4 ;
73098   float result;
73099
73100   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73101   arg2 = (unsigned int)jarg2;
73102   arg3 = (unsigned int *)jarg3;
73103   arg4 = jarg4 ? true : false;
73104   {
73105     try {
73106       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73107     } catch (std::out_of_range& e) {
73108       {
73109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73110       };
73111     } catch (std::exception& e) {
73112       {
73113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73114       };
73115     } catch (Dali::DaliException e) {
73116       {
73117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73118       };
73119     } catch (...) {
73120       {
73121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73122       };
73123     }
73124   }
73125
73126   jresult = result;
73127   return jresult;
73128 }
73129
73130
73131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73132   unsigned int jresult ;
73133   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73134   float arg2 ;
73135   bool arg3 ;
73136   unsigned int result;
73137
73138   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73139   arg2 = (float)jarg2;
73140   arg3 = jarg3 ? true : false;
73141   {
73142     try {
73143       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
73144     } catch (std::out_of_range& e) {
73145       {
73146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73147       };
73148     } catch (std::exception& e) {
73149       {
73150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73151       };
73152     } catch (Dali::DaliException e) {
73153       {
73154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73155       };
73156     } catch (...) {
73157       {
73158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73159       };
73160     }
73161   }
73162
73163   jresult = result;
73164   return jresult;
73165 }
73166
73167
73168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
73169   unsigned int jresult ;
73170   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73171   unsigned int result;
73172
73173   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73174   {
73175     try {
73176       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73177     } catch (std::out_of_range& e) {
73178       {
73179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73180       };
73181     } catch (std::exception& e) {
73182       {
73183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73184       };
73185     } catch (Dali::DaliException e) {
73186       {
73187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73188       };
73189     } catch (...) {
73190       {
73191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73192       };
73193     }
73194   }
73195
73196   jresult = result;
73197   return jresult;
73198 }
73199
73200
73201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73202   int jresult ;
73203   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73204   Dali::Toolkit::Ruler::RulerType result;
73205
73206   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73207   {
73208     try {
73209       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73210     } catch (std::out_of_range& e) {
73211       {
73212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73213       };
73214     } catch (std::exception& e) {
73215       {
73216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73217       };
73218     } catch (Dali::DaliException e) {
73219       {
73220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73221       };
73222     } catch (...) {
73223       {
73224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73225       };
73226     }
73227   }
73228
73229   jresult = (int)result;
73230   return jresult;
73231 }
73232
73233
73234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73235   unsigned int jresult ;
73236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73237   bool result;
73238
73239   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73240   {
73241     try {
73242       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73243     } catch (std::out_of_range& e) {
73244       {
73245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73246       };
73247     } catch (std::exception& e) {
73248       {
73249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (Dali::DaliException e) {
73252       {
73253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73254       };
73255     } catch (...) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73258       };
73259     }
73260   }
73261
73262   jresult = result;
73263   return jresult;
73264 }
73265
73266
73267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73268   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73269
73270   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73271   {
73272     try {
73273       (arg1)->Enable();
73274     } catch (std::out_of_range& e) {
73275       {
73276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73277       };
73278     } catch (std::exception& e) {
73279       {
73280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73281       };
73282     } catch (Dali::DaliException e) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73285       };
73286     } catch (...) {
73287       {
73288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73289       };
73290     }
73291   }
73292
73293 }
73294
73295
73296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73297   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73298
73299   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73300   {
73301     try {
73302       (arg1)->Disable();
73303     } catch (std::out_of_range& e) {
73304       {
73305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73306       };
73307     } catch (std::exception& e) {
73308       {
73309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73310       };
73311     } catch (Dali::DaliException e) {
73312       {
73313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73314       };
73315     } catch (...) {
73316       {
73317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73318       };
73319     }
73320   }
73321
73322 }
73323
73324
73325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73326   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73327   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73328   Dali::Toolkit::RulerDomain *argp2 ;
73329
73330   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73331   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73332   if (!argp2) {
73333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73334     return ;
73335   }
73336   arg2 = *argp2;
73337   {
73338     try {
73339       (arg1)->SetDomain(arg2);
73340     } catch (std::out_of_range& e) {
73341       {
73342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73343       };
73344     } catch (std::exception& e) {
73345       {
73346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73347       };
73348     } catch (Dali::DaliException e) {
73349       {
73350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73351       };
73352     } catch (...) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73355       };
73356     }
73357   }
73358
73359 }
73360
73361
73362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73363   void * jresult ;
73364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73365   Dali::Toolkit::RulerDomain *result = 0 ;
73366
73367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73368   {
73369     try {
73370       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73371     } catch (std::out_of_range& e) {
73372       {
73373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73374       };
73375     } catch (std::exception& e) {
73376       {
73377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73378       };
73379     } catch (Dali::DaliException e) {
73380       {
73381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73382       };
73383     } catch (...) {
73384       {
73385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73386       };
73387     }
73388   }
73389
73390   jresult = (void *)result;
73391   return jresult;
73392 }
73393
73394
73395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73396   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73397
73398   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73399   {
73400     try {
73401       (arg1)->DisableDomain();
73402     } catch (std::out_of_range& e) {
73403       {
73404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73405       };
73406     } catch (std::exception& e) {
73407       {
73408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73409       };
73410     } catch (Dali::DaliException e) {
73411       {
73412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73413       };
73414     } catch (...) {
73415       {
73416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73417       };
73418     }
73419   }
73420
73421 }
73422
73423
73424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73425   float jresult ;
73426   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73427   float arg2 ;
73428   float arg3 ;
73429   float arg4 ;
73430   float result;
73431
73432   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73433   arg2 = (float)jarg2;
73434   arg3 = (float)jarg3;
73435   arg4 = (float)jarg4;
73436   {
73437     try {
73438       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73439     } catch (std::out_of_range& e) {
73440       {
73441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73442       };
73443     } catch (std::exception& e) {
73444       {
73445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73446       };
73447     } catch (Dali::DaliException e) {
73448       {
73449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73450       };
73451     } catch (...) {
73452       {
73453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73454       };
73455     }
73456   }
73457
73458   jresult = result;
73459   return jresult;
73460 }
73461
73462
73463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73464   float jresult ;
73465   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73466   float arg2 ;
73467   float arg3 ;
73468   float result;
73469
73470   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73471   arg2 = (float)jarg2;
73472   arg3 = (float)jarg3;
73473   {
73474     try {
73475       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73476     } catch (std::out_of_range& e) {
73477       {
73478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73479       };
73480     } catch (std::exception& e) {
73481       {
73482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73483       };
73484     } catch (Dali::DaliException e) {
73485       {
73486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73487       };
73488     } catch (...) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73491       };
73492     }
73493   }
73494
73495   jresult = result;
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73501   float jresult ;
73502   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73503   float arg2 ;
73504   float result;
73505
73506   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73507   arg2 = (float)jarg2;
73508   {
73509     try {
73510       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73511     } catch (std::out_of_range& e) {
73512       {
73513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73514       };
73515     } catch (std::exception& e) {
73516       {
73517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (Dali::DaliException e) {
73520       {
73521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73526       };
73527     }
73528   }
73529
73530   jresult = result;
73531   return jresult;
73532 }
73533
73534
73535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73536   float jresult ;
73537   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73538   float arg2 ;
73539   float arg3 ;
73540   float arg4 ;
73541   Dali::Toolkit::ClampState *arg5 = 0 ;
73542   float result;
73543
73544   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73545   arg2 = (float)jarg2;
73546   arg3 = (float)jarg3;
73547   arg4 = (float)jarg4;
73548   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73549   if (!arg5) {
73550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73551     return 0;
73552   }
73553   {
73554     try {
73555       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73556     } catch (std::out_of_range& e) {
73557       {
73558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (std::exception& e) {
73561       {
73562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73563       };
73564     } catch (Dali::DaliException e) {
73565       {
73566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73567       };
73568     } catch (...) {
73569       {
73570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73571       };
73572     }
73573   }
73574
73575   jresult = result;
73576   return jresult;
73577 }
73578
73579
73580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73581   float jresult ;
73582   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73583   float arg2 ;
73584   float arg3 ;
73585   float arg4 ;
73586   float arg5 ;
73587   float result;
73588
73589   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73590   arg2 = (float)jarg2;
73591   arg3 = (float)jarg3;
73592   arg4 = (float)jarg4;
73593   arg5 = (float)jarg5;
73594   {
73595     try {
73596       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73597     } catch (std::out_of_range& e) {
73598       {
73599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73600       };
73601     } catch (std::exception& e) {
73602       {
73603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73604       };
73605     } catch (Dali::DaliException e) {
73606       {
73607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73608       };
73609     } catch (...) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73612       };
73613     }
73614   }
73615
73616   jresult = result;
73617   return jresult;
73618 }
73619
73620
73621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73622   float jresult ;
73623   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73624   float arg2 ;
73625   float arg3 ;
73626   float arg4 ;
73627   float result;
73628
73629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73630   arg2 = (float)jarg2;
73631   arg3 = (float)jarg3;
73632   arg4 = (float)jarg4;
73633   {
73634     try {
73635       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73636     } catch (std::out_of_range& e) {
73637       {
73638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73639       };
73640     } catch (std::exception& e) {
73641       {
73642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73643       };
73644     } catch (Dali::DaliException e) {
73645       {
73646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73647       };
73648     } catch (...) {
73649       {
73650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73651       };
73652     }
73653   }
73654
73655   jresult = result;
73656   return jresult;
73657 }
73658
73659
73660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73661   float jresult ;
73662   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73663   float arg2 ;
73664   float arg3 ;
73665   float result;
73666
73667   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73668   arg2 = (float)jarg2;
73669   arg3 = (float)jarg3;
73670   {
73671     try {
73672       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73673     } catch (std::out_of_range& e) {
73674       {
73675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73676       };
73677     } catch (std::exception& e) {
73678       {
73679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73680       };
73681     } catch (Dali::DaliException e) {
73682       {
73683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73684       };
73685     } catch (...) {
73686       {
73687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73688       };
73689     }
73690   }
73691
73692   jresult = result;
73693   return jresult;
73694 }
73695
73696
73697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73698   float jresult ;
73699   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73700   float arg2 ;
73701   float result;
73702
73703   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73704   arg2 = (float)jarg2;
73705   {
73706     try {
73707       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73708     } catch (std::out_of_range& e) {
73709       {
73710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73711       };
73712     } catch (std::exception& e) {
73713       {
73714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (Dali::DaliException e) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73719       };
73720     } catch (...) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73723       };
73724     }
73725   }
73726
73727   jresult = result;
73728   return jresult;
73729 }
73730
73731
73732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73733   float jresult ;
73734   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73735   float arg2 ;
73736   float arg3 ;
73737   float arg4 ;
73738   float arg5 ;
73739   Dali::Toolkit::ClampState *arg6 = 0 ;
73740   float result;
73741
73742   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73743   arg2 = (float)jarg2;
73744   arg3 = (float)jarg3;
73745   arg4 = (float)jarg4;
73746   arg5 = (float)jarg5;
73747   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73748   if (!arg6) {
73749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73750     return 0;
73751   }
73752   {
73753     try {
73754       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (Dali::DaliException e) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773
73774   jresult = result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73780   void * jresult ;
73781   Dali::Toolkit::DefaultRuler *result = 0 ;
73782
73783   {
73784     try {
73785       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73786     } catch (std::out_of_range& e) {
73787       {
73788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73789       };
73790     } catch (std::exception& e) {
73791       {
73792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73793       };
73794     } catch (Dali::DaliException e) {
73795       {
73796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73797       };
73798     } catch (...) {
73799       {
73800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73801       };
73802     }
73803   }
73804
73805   jresult = (void *)result;
73806   return jresult;
73807 }
73808
73809
73810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73811   float jresult ;
73812   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73813   float arg2 ;
73814   float arg3 ;
73815   float result;
73816
73817   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73818   arg2 = (float)jarg2;
73819   arg3 = (float)jarg3;
73820   {
73821     try {
73822       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73823     } catch (std::out_of_range& e) {
73824       {
73825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73826       };
73827     } catch (std::exception& e) {
73828       {
73829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73830       };
73831     } catch (Dali::DaliException e) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73834       };
73835     } catch (...) {
73836       {
73837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73838       };
73839     }
73840   }
73841
73842   jresult = result;
73843   return jresult;
73844 }
73845
73846
73847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73848   float jresult ;
73849   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73850   unsigned int arg2 ;
73851   unsigned int *arg3 = 0 ;
73852   bool arg4 ;
73853   float result;
73854
73855   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73856   arg2 = (unsigned int)jarg2;
73857   arg3 = (unsigned int *)jarg3;
73858   arg4 = jarg4 ? true : false;
73859   {
73860     try {
73861       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73862     } catch (std::out_of_range& e) {
73863       {
73864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73865       };
73866     } catch (std::exception& e) {
73867       {
73868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73869       };
73870     } catch (Dali::DaliException e) {
73871       {
73872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73873       };
73874     } catch (...) {
73875       {
73876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73877       };
73878     }
73879   }
73880
73881   jresult = result;
73882   return jresult;
73883 }
73884
73885
73886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73887   unsigned int jresult ;
73888   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73889   float arg2 ;
73890   bool arg3 ;
73891   unsigned int result;
73892
73893   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73894   arg2 = (float)jarg2;
73895   arg3 = jarg3 ? true : false;
73896   {
73897     try {
73898       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73899     } catch (std::out_of_range& e) {
73900       {
73901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73902       };
73903     } catch (std::exception& e) {
73904       {
73905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73906       };
73907     } catch (Dali::DaliException e) {
73908       {
73909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73910       };
73911     } catch (...) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73914       };
73915     }
73916   }
73917
73918   jresult = result;
73919   return jresult;
73920 }
73921
73922
73923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73924   unsigned int jresult ;
73925   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73926   unsigned int result;
73927
73928   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73929   {
73930     try {
73931       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73932     } catch (std::out_of_range& e) {
73933       {
73934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73935       };
73936     } catch (std::exception& e) {
73937       {
73938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73939       };
73940     } catch (Dali::DaliException e) {
73941       {
73942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73943       };
73944     } catch (...) {
73945       {
73946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73947       };
73948     }
73949   }
73950
73951   jresult = result;
73952   return jresult;
73953 }
73954
73955
73956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73957   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73958
73959   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73960   {
73961     try {
73962       delete arg1;
73963     } catch (std::out_of_range& e) {
73964       {
73965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73966       };
73967     } catch (std::exception& e) {
73968       {
73969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73970       };
73971     } catch (Dali::DaliException e) {
73972       {
73973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73974       };
73975     } catch (...) {
73976       {
73977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73978       };
73979     }
73980   }
73981
73982 }
73983
73984
73985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73986   void * jresult ;
73987   float arg1 ;
73988   Dali::Toolkit::FixedRuler *result = 0 ;
73989
73990   arg1 = (float)jarg1;
73991   {
73992     try {
73993       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73994     } catch (std::out_of_range& e) {
73995       {
73996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73997       };
73998     } catch (std::exception& e) {
73999       {
74000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74001       };
74002     } catch (Dali::DaliException e) {
74003       {
74004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74005       };
74006     } catch (...) {
74007       {
74008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74009       };
74010     }
74011   }
74012
74013   jresult = (void *)result;
74014   return jresult;
74015 }
74016
74017
74018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
74019   void * jresult ;
74020   Dali::Toolkit::FixedRuler *result = 0 ;
74021
74022   {
74023     try {
74024       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
74025     } catch (std::out_of_range& e) {
74026       {
74027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74028       };
74029     } catch (std::exception& e) {
74030       {
74031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74032       };
74033     } catch (Dali::DaliException e) {
74034       {
74035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74036       };
74037     } catch (...) {
74038       {
74039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74040       };
74041     }
74042   }
74043
74044   jresult = (void *)result;
74045   return jresult;
74046 }
74047
74048
74049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
74050   float jresult ;
74051   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74052   float arg2 ;
74053   float arg3 ;
74054   float result;
74055
74056   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74057   arg2 = (float)jarg2;
74058   arg3 = (float)jarg3;
74059   {
74060     try {
74061       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
74062     } catch (std::out_of_range& e) {
74063       {
74064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74065       };
74066     } catch (std::exception& e) {
74067       {
74068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74069       };
74070     } catch (Dali::DaliException e) {
74071       {
74072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74073       };
74074     } catch (...) {
74075       {
74076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74077       };
74078     }
74079   }
74080
74081   jresult = result;
74082   return jresult;
74083 }
74084
74085
74086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74087   float jresult ;
74088   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74089   unsigned int arg2 ;
74090   unsigned int *arg3 = 0 ;
74091   bool arg4 ;
74092   float result;
74093
74094   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74095   arg2 = (unsigned int)jarg2;
74096   arg3 = (unsigned int *)jarg3;
74097   arg4 = jarg4 ? true : false;
74098   {
74099     try {
74100       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74101     } catch (std::out_of_range& e) {
74102       {
74103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74104       };
74105     } catch (std::exception& e) {
74106       {
74107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74108       };
74109     } catch (Dali::DaliException e) {
74110       {
74111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74112       };
74113     } catch (...) {
74114       {
74115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74116       };
74117     }
74118   }
74119
74120   jresult = result;
74121   return jresult;
74122 }
74123
74124
74125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74126   unsigned int jresult ;
74127   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74128   float arg2 ;
74129   bool arg3 ;
74130   unsigned int result;
74131
74132   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74133   arg2 = (float)jarg2;
74134   arg3 = jarg3 ? true : false;
74135   {
74136     try {
74137       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74138     } catch (std::out_of_range& e) {
74139       {
74140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74141       };
74142     } catch (std::exception& e) {
74143       {
74144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74145       };
74146     } catch (Dali::DaliException e) {
74147       {
74148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74149       };
74150     } catch (...) {
74151       {
74152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74153       };
74154     }
74155   }
74156
74157   jresult = result;
74158   return jresult;
74159 }
74160
74161
74162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
74163   unsigned int jresult ;
74164   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74165   unsigned int result;
74166
74167   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74168   {
74169     try {
74170       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
74171     } catch (std::out_of_range& e) {
74172       {
74173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74174       };
74175     } catch (std::exception& e) {
74176       {
74177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74178       };
74179     } catch (Dali::DaliException e) {
74180       {
74181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74182       };
74183     } catch (...) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74186       };
74187     }
74188   }
74189
74190   jresult = result;
74191   return jresult;
74192 }
74193
74194
74195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74196   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74197
74198   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74199   {
74200     try {
74201       delete arg1;
74202     } catch (std::out_of_range& e) {
74203       {
74204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74205       };
74206     } catch (std::exception& e) {
74207       {
74208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74209       };
74210     } catch (Dali::DaliException e) {
74211       {
74212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74213       };
74214     } catch (...) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74217       };
74218     }
74219   }
74220
74221 }
74222
74223
74224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74225   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74226   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74227
74228   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74229   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74230   if (arg1) (arg1)->scale = *arg2;
74231 }
74232
74233
74234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74235   void * jresult ;
74236   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74237   Dali::Toolkit::ClampState2D *result = 0 ;
74238
74239   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74240   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74241   jresult = (void *)result;
74242   return jresult;
74243 }
74244
74245
74246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74247   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74248   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74249
74250   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74251   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74252   if (arg1) (arg1)->position = *arg2;
74253 }
74254
74255
74256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74257   void * jresult ;
74258   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74259   Dali::Toolkit::ClampState2D *result = 0 ;
74260
74261   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74262   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74263   jresult = (void *)result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74269   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74270   Dali::Toolkit::ClampState arg2 ;
74271
74272   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74273   arg2 = (Dali::Toolkit::ClampState)jarg2;
74274   if (arg1) (arg1)->rotation = arg2;
74275 }
74276
74277
74278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74279   int jresult ;
74280   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74281   Dali::Toolkit::ClampState result;
74282
74283   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74284   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74285   jresult = (int)result;
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74291   void * jresult ;
74292   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74293
74294   {
74295     try {
74296       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74297     } catch (std::out_of_range& e) {
74298       {
74299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74300       };
74301     } catch (std::exception& e) {
74302       {
74303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74304       };
74305     } catch (Dali::DaliException e) {
74306       {
74307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74308       };
74309     } catch (...) {
74310       {
74311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74312       };
74313     }
74314   }
74315
74316   jresult = (void *)result;
74317   return jresult;
74318 }
74319
74320
74321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74322   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74323
74324   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74325   {
74326     try {
74327       delete arg1;
74328     } catch (std::out_of_range& e) {
74329       {
74330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74331       };
74332     } catch (std::exception& e) {
74333       {
74334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74335       };
74336     } catch (Dali::DaliException e) {
74337       {
74338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74339       };
74340     } catch (...) {
74341       {
74342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74343       };
74344     }
74345   }
74346
74347 }
74348
74349
74350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74351   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74352   Dali::Toolkit::SnapType arg2 ;
74353
74354   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74355   arg2 = (Dali::Toolkit::SnapType)jarg2;
74356   if (arg1) (arg1)->type = arg2;
74357 }
74358
74359
74360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74361   int jresult ;
74362   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74363   Dali::Toolkit::SnapType result;
74364
74365   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74366   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74367   jresult = (int)result;
74368   return jresult;
74369 }
74370
74371
74372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74373   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74374   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74375
74376   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74377   arg2 = (Dali::Vector2 *)jarg2;
74378   if (arg1) (arg1)->position = *arg2;
74379 }
74380
74381
74382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74383   void * jresult ;
74384   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74385   Dali::Vector2 *result = 0 ;
74386
74387   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74388   result = (Dali::Vector2 *)& ((arg1)->position);
74389   jresult = (void *)result;
74390   return jresult;
74391 }
74392
74393
74394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74395   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74396   float arg2 ;
74397
74398   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74399   arg2 = (float)jarg2;
74400   if (arg1) (arg1)->duration = arg2;
74401 }
74402
74403
74404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74405   float jresult ;
74406   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74407   float result;
74408
74409   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74410   result = (float) ((arg1)->duration);
74411   jresult = result;
74412   return jresult;
74413 }
74414
74415
74416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74417   void * jresult ;
74418   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74419
74420   {
74421     try {
74422       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74423     } catch (std::out_of_range& e) {
74424       {
74425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74426       };
74427     } catch (std::exception& e) {
74428       {
74429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74430       };
74431     } catch (Dali::DaliException e) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74434       };
74435     } catch (...) {
74436       {
74437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74438       };
74439     }
74440   }
74441
74442   jresult = (void *)result;
74443   return jresult;
74444 }
74445
74446
74447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74448   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74449
74450   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74451   {
74452     try {
74453       delete arg1;
74454     } catch (std::out_of_range& e) {
74455       {
74456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74457       };
74458     } catch (std::exception& e) {
74459       {
74460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74461       };
74462     } catch (Dali::DaliException e) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74465       };
74466     } catch (...) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74469       };
74470     }
74471   }
74472
74473 }
74474
74475
74476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74477   int jresult ;
74478   int result;
74479
74480   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74481   jresult = (int)result;
74482   return jresult;
74483 }
74484
74485
74486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74487   int jresult ;
74488   int result;
74489
74490   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74491   jresult = (int)result;
74492   return jresult;
74493 }
74494
74495
74496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74497   int jresult ;
74498   int result;
74499
74500   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74501   jresult = (int)result;
74502   return jresult;
74503 }
74504
74505
74506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74507   int jresult ;
74508   int result;
74509
74510   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74511   jresult = (int)result;
74512   return jresult;
74513 }
74514
74515
74516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74517   int jresult ;
74518   int result;
74519
74520   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74521   jresult = (int)result;
74522   return jresult;
74523 }
74524
74525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74526   int jresult ;
74527   int result;
74528
74529   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74530   jresult = (int)result;
74531   return jresult;
74532 }
74533
74534
74535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74536   int jresult ;
74537   int result;
74538
74539   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74540   jresult = (int)result;
74541   return jresult;
74542 }
74543
74544
74545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74546   int jresult ;
74547   int result;
74548
74549   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74550   jresult = (int)result;
74551   return jresult;
74552 }
74553
74554
74555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74556   int jresult ;
74557   int result;
74558
74559   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74560   jresult = (int)result;
74561   return jresult;
74562 }
74563
74564
74565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74566   int jresult ;
74567   int result;
74568
74569   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74570   jresult = (int)result;
74571   return jresult;
74572 }
74573
74574
74575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74576   int jresult ;
74577   int result;
74578
74579   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74580   jresult = (int)result;
74581   return jresult;
74582 }
74583
74584
74585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74586   int jresult ;
74587   int result;
74588
74589   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74590   jresult = (int)result;
74591   return jresult;
74592 }
74593
74594
74595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74596   int jresult ;
74597   int result;
74598
74599   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74600   jresult = (int)result;
74601   return jresult;
74602 }
74603
74604
74605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74606   int jresult ;
74607   int result;
74608
74609   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74610   jresult = (int)result;
74611   return jresult;
74612 }
74613
74614
74615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74616   int jresult ;
74617   int result;
74618
74619   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74620   jresult = (int)result;
74621   return jresult;
74622 }
74623
74624
74625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74626   int jresult ;
74627   int result;
74628
74629   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74630   jresult = (int)result;
74631   return jresult;
74632 }
74633
74634
74635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74636   int jresult ;
74637   int result;
74638
74639   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74640   jresult = (int)result;
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74646   int jresult ;
74647   int result;
74648
74649   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74650   jresult = (int)result;
74651   return jresult;
74652 }
74653
74654
74655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74656   int jresult ;
74657   int result;
74658
74659   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74660   jresult = (int)result;
74661   return jresult;
74662 }
74663
74664
74665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74666   int jresult ;
74667   int result;
74668
74669   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74670   jresult = (int)result;
74671   return jresult;
74672 }
74673
74674
74675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74676   int jresult ;
74677   int result;
74678
74679   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74680   jresult = (int)result;
74681   return jresult;
74682 }
74683
74684
74685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74686   int jresult ;
74687   int result;
74688
74689   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74690   jresult = (int)result;
74691   return jresult;
74692 }
74693
74694
74695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74696   int jresult ;
74697   int result;
74698
74699   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74700   jresult = (int)result;
74701   return jresult;
74702 }
74703
74704
74705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74706   int jresult ;
74707   int result;
74708
74709   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74710   jresult = (int)result;
74711   return jresult;
74712 }
74713
74714
74715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74716   int jresult ;
74717   int result;
74718
74719   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74720   jresult = (int)result;
74721   return jresult;
74722 }
74723
74724
74725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74726   int jresult ;
74727   int result;
74728
74729   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74730   jresult = (int)result;
74731   return jresult;
74732 }
74733
74734
74735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74736   void * jresult ;
74737   Dali::Toolkit::ScrollView::Property *result = 0 ;
74738
74739   {
74740     try {
74741       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74749       };
74750     } catch (Dali::DaliException e) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74757       };
74758     }
74759   }
74760
74761   jresult = (void *)result;
74762   return jresult;
74763 }
74764
74765
74766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74767   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74768
74769   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74770   {
74771     try {
74772       delete arg1;
74773     } catch (std::out_of_range& e) {
74774       {
74775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74776       };
74777     } catch (std::exception& e) {
74778       {
74779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74780       };
74781     } catch (Dali::DaliException e) {
74782       {
74783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74784       };
74785     } catch (...) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74788       };
74789     }
74790   }
74791
74792 }
74793
74794
74795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74796   void * jresult ;
74797   Dali::Toolkit::ScrollView *result = 0 ;
74798
74799   {
74800     try {
74801       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74802     } catch (std::out_of_range& e) {
74803       {
74804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74805       };
74806     } catch (std::exception& e) {
74807       {
74808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74809       };
74810     } catch (Dali::DaliException e) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74813       };
74814     } catch (...) {
74815       {
74816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74817       };
74818     }
74819   }
74820
74821   jresult = (void *)result;
74822   return jresult;
74823 }
74824
74825
74826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74827   void * jresult ;
74828   Dali::Toolkit::ScrollView *arg1 = 0 ;
74829   Dali::Toolkit::ScrollView *result = 0 ;
74830
74831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74832   if (!arg1) {
74833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74834     return 0;
74835   }
74836   {
74837     try {
74838       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (Dali::DaliException e) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74850       };
74851     } catch (...) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74854       };
74855     }
74856   }
74857
74858   jresult = (void *)result;
74859   return jresult;
74860 }
74861
74862
74863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74864   void * jresult ;
74865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74866   Dali::Toolkit::ScrollView *arg2 = 0 ;
74867   Dali::Toolkit::ScrollView *result = 0 ;
74868
74869   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74870   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74871   if (!arg2) {
74872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74873     return 0;
74874   }
74875   {
74876     try {
74877       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74878     } catch (std::out_of_range& e) {
74879       {
74880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74881       };
74882     } catch (std::exception& e) {
74883       {
74884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74885       };
74886     } catch (Dali::DaliException e) {
74887       {
74888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74889       };
74890     } catch (...) {
74891       {
74892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74893       };
74894     }
74895   }
74896
74897   jresult = (void *)result;
74898   return jresult;
74899 }
74900
74901
74902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74904
74905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74906   {
74907     try {
74908       delete arg1;
74909     } catch (std::out_of_range& e) {
74910       {
74911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74912       };
74913     } catch (std::exception& e) {
74914       {
74915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74916       };
74917     } catch (Dali::DaliException e) {
74918       {
74919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74920       };
74921     } catch (...) {
74922       {
74923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74924       };
74925     }
74926   }
74927
74928 }
74929
74930
74931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74932   void * jresult ;
74933   Dali::Toolkit::ScrollView result;
74934
74935   {
74936     try {
74937       result = Dali::Toolkit::ScrollView::New();
74938     } catch (std::out_of_range& e) {
74939       {
74940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74941       };
74942     } catch (std::exception& e) {
74943       {
74944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74945       };
74946     } catch (Dali::DaliException e) {
74947       {
74948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74949       };
74950     } catch (...) {
74951       {
74952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74953       };
74954     }
74955   }
74956
74957   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74958   return jresult;
74959 }
74960
74961
74962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74963   void * jresult ;
74964   Dali::BaseHandle arg1 ;
74965   Dali::BaseHandle *argp1 ;
74966   Dali::Toolkit::ScrollView result;
74967
74968   argp1 = (Dali::BaseHandle *)jarg1;
74969   if (!argp1) {
74970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74971     return 0;
74972   }
74973   arg1 = *argp1;
74974   {
74975     try {
74976       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74977     } catch (std::out_of_range& e) {
74978       {
74979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74980       };
74981     } catch (std::exception& e) {
74982       {
74983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (Dali::DaliException e) {
74986       {
74987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74988       };
74989     } catch (...) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74992       };
74993     }
74994   }
74995
74996   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74997   return jresult;
74998 }
74999
75000
75001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
75002   void * jresult ;
75003   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75004   Dali::AlphaFunction result;
75005
75006   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75007   {
75008     try {
75009       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
75010     } catch (std::out_of_range& e) {
75011       {
75012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75013       };
75014     } catch (std::exception& e) {
75015       {
75016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75017       };
75018     } catch (Dali::DaliException e) {
75019       {
75020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75021       };
75022     } catch (...) {
75023       {
75024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75025       };
75026     }
75027   }
75028
75029   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75030   return jresult;
75031 }
75032
75033
75034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
75035   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75036   Dali::AlphaFunction arg2 ;
75037   Dali::AlphaFunction *argp2 ;
75038
75039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75040   argp2 = (Dali::AlphaFunction *)jarg2;
75041   if (!argp2) {
75042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75043     return ;
75044   }
75045   arg2 = *argp2;
75046   {
75047     try {
75048       (arg1)->SetScrollSnapAlphaFunction(arg2);
75049     } catch (std::out_of_range& e) {
75050       {
75051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75052       };
75053     } catch (std::exception& e) {
75054       {
75055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75056       };
75057     } catch (Dali::DaliException e) {
75058       {
75059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75060       };
75061     } catch (...) {
75062       {
75063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75064       };
75065     }
75066   }
75067
75068 }
75069
75070
75071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
75072   void * jresult ;
75073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75074   Dali::AlphaFunction result;
75075
75076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75077   {
75078     try {
75079       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
75080     } catch (std::out_of_range& e) {
75081       {
75082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75083       };
75084     } catch (std::exception& e) {
75085       {
75086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75087       };
75088     } catch (Dali::DaliException e) {
75089       {
75090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75091       };
75092     } catch (...) {
75093       {
75094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75095       };
75096     }
75097   }
75098
75099   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75100   return jresult;
75101 }
75102
75103
75104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
75105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75106   Dali::AlphaFunction arg2 ;
75107   Dali::AlphaFunction *argp2 ;
75108
75109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75110   argp2 = (Dali::AlphaFunction *)jarg2;
75111   if (!argp2) {
75112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75113     return ;
75114   }
75115   arg2 = *argp2;
75116   {
75117     try {
75118       (arg1)->SetScrollFlickAlphaFunction(arg2);
75119     } catch (std::out_of_range& e) {
75120       {
75121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75122       };
75123     } catch (std::exception& e) {
75124       {
75125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75126       };
75127     } catch (Dali::DaliException e) {
75128       {
75129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75130       };
75131     } catch (...) {
75132       {
75133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75134       };
75135     }
75136   }
75137
75138 }
75139
75140
75141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
75142   float jresult ;
75143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75144   float result;
75145
75146   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75147   {
75148     try {
75149       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
75150     } catch (std::out_of_range& e) {
75151       {
75152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75153       };
75154     } catch (std::exception& e) {
75155       {
75156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75157       };
75158     } catch (Dali::DaliException e) {
75159       {
75160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75161       };
75162     } catch (...) {
75163       {
75164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75165       };
75166     }
75167   }
75168
75169   jresult = result;
75170   return jresult;
75171 }
75172
75173
75174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
75175   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75176   float arg2 ;
75177
75178   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75179   arg2 = (float)jarg2;
75180   {
75181     try {
75182       (arg1)->SetScrollSnapDuration(arg2);
75183     } catch (std::out_of_range& e) {
75184       {
75185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75186       };
75187     } catch (std::exception& e) {
75188       {
75189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75190       };
75191     } catch (Dali::DaliException e) {
75192       {
75193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75194       };
75195     } catch (...) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75198       };
75199     }
75200   }
75201
75202 }
75203
75204
75205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75206   float jresult ;
75207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75208   float result;
75209
75210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75211   {
75212     try {
75213       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75214     } catch (std::out_of_range& e) {
75215       {
75216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75217       };
75218     } catch (std::exception& e) {
75219       {
75220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (Dali::DaliException e) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75225       };
75226     } catch (...) {
75227       {
75228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75229       };
75230     }
75231   }
75232
75233   jresult = result;
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75240   float arg2 ;
75241
75242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75243   arg2 = (float)jarg2;
75244   {
75245     try {
75246       (arg1)->SetScrollFlickDuration(arg2);
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75254       };
75255     } catch (Dali::DaliException e) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75262       };
75263     }
75264   }
75265
75266 }
75267
75268
75269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75271   Dali::Toolkit::RulerPtr arg2 ;
75272   Dali::Toolkit::RulerPtr *argp2 ;
75273
75274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75275   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75276   if (!argp2) {
75277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75278     return ;
75279   }
75280   arg2 = *argp2;
75281   {
75282     try {
75283       (arg1)->SetRulerX(arg2);
75284     } catch (std::out_of_range& e) {
75285       {
75286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75287       };
75288     } catch (std::exception& e) {
75289       {
75290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75291       };
75292     } catch (Dali::DaliException e) {
75293       {
75294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75295       };
75296     } catch (...) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75299       };
75300     }
75301   }
75302
75303 }
75304
75305
75306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75307   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75308   Dali::Toolkit::RulerPtr arg2 ;
75309   Dali::Toolkit::RulerPtr *argp2 ;
75310
75311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75312   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75313   if (!argp2) {
75314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75315     return ;
75316   }
75317   arg2 = *argp2;
75318   {
75319     try {
75320       (arg1)->SetRulerY(arg2);
75321     } catch (std::out_of_range& e) {
75322       {
75323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75324       };
75325     } catch (std::exception& e) {
75326       {
75327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75328       };
75329     } catch (Dali::DaliException e) {
75330       {
75331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75332       };
75333     } catch (...) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75336       };
75337     }
75338   }
75339
75340 }
75341
75342
75343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75345   bool arg2 ;
75346
75347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75348   arg2 = jarg2 ? true : false;
75349   {
75350     try {
75351       (arg1)->SetScrollSensitive(arg2);
75352     } catch (std::out_of_range& e) {
75353       {
75354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75355       };
75356     } catch (std::exception& e) {
75357       {
75358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75359       };
75360     } catch (Dali::DaliException e) {
75361       {
75362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75363       };
75364     } catch (...) {
75365       {
75366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75367       };
75368     }
75369   }
75370
75371 }
75372
75373
75374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75376   float arg2 ;
75377   float arg3 ;
75378
75379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75380   arg2 = (float)jarg2;
75381   arg3 = (float)jarg3;
75382   {
75383     try {
75384       (arg1)->SetMaxOvershoot(arg2,arg3);
75385     } catch (std::out_of_range& e) {
75386       {
75387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75388       };
75389     } catch (std::exception& e) {
75390       {
75391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75392       };
75393     } catch (Dali::DaliException e) {
75394       {
75395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75396       };
75397     } catch (...) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75400       };
75401     }
75402   }
75403
75404 }
75405
75406
75407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75408   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75409   Dali::AlphaFunction arg2 ;
75410   Dali::AlphaFunction *argp2 ;
75411
75412   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75413   argp2 = (Dali::AlphaFunction *)jarg2;
75414   if (!argp2) {
75415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75416     return ;
75417   }
75418   arg2 = *argp2;
75419   {
75420     try {
75421       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75422     } catch (std::out_of_range& e) {
75423       {
75424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75425       };
75426     } catch (std::exception& e) {
75427       {
75428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75429       };
75430     } catch (Dali::DaliException e) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75433       };
75434     } catch (...) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75437       };
75438     }
75439   }
75440
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75446   float arg2 ;
75447
75448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75449   arg2 = (float)jarg2;
75450   {
75451     try {
75452       (arg1)->SetSnapOvershootDuration(arg2);
75453     } catch (std::out_of_range& e) {
75454       {
75455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75456       };
75457     } catch (std::exception& e) {
75458       {
75459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75460       };
75461     } catch (Dali::DaliException e) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75464       };
75465     } catch (...) {
75466       {
75467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75468       };
75469     }
75470   }
75471
75472 }
75473
75474
75475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75476   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75477   bool arg2 ;
75478
75479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75480   arg2 = jarg2 ? true : false;
75481   {
75482     try {
75483       (arg1)->SetActorAutoSnap(arg2);
75484     } catch (std::out_of_range& e) {
75485       {
75486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75487       };
75488     } catch (std::exception& e) {
75489       {
75490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75491       };
75492     } catch (Dali::DaliException e) {
75493       {
75494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75495       };
75496     } catch (...) {
75497       {
75498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75499       };
75500     }
75501   }
75502
75503 }
75504
75505
75506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75508   bool arg2 ;
75509
75510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75511   arg2 = jarg2 ? true : false;
75512   {
75513     try {
75514       (arg1)->SetWrapMode(arg2);
75515     } catch (std::out_of_range& e) {
75516       {
75517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75518       };
75519     } catch (std::exception& e) {
75520       {
75521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75522       };
75523     } catch (Dali::DaliException e) {
75524       {
75525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75530       };
75531     }
75532   }
75533
75534 }
75535
75536
75537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75538   int jresult ;
75539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75540   int result;
75541
75542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75543   {
75544     try {
75545       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75546     } catch (std::out_of_range& e) {
75547       {
75548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75549       };
75550     } catch (std::exception& e) {
75551       {
75552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75553       };
75554     } catch (Dali::DaliException e) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75557       };
75558     } catch (...) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75561       };
75562     }
75563   }
75564
75565   jresult = result;
75566   return jresult;
75567 }
75568
75569
75570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75572   int arg2 ;
75573
75574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75575   arg2 = (int)jarg2;
75576   {
75577     try {
75578       (arg1)->SetScrollUpdateDistance(arg2);
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75586       };
75587     } catch (Dali::DaliException e) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75590       };
75591     } catch (...) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75594       };
75595     }
75596   }
75597
75598 }
75599
75600
75601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75602   unsigned int jresult ;
75603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75604   bool result;
75605
75606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75607   {
75608     try {
75609       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75610     } catch (std::out_of_range& e) {
75611       {
75612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75613       };
75614     } catch (std::exception& e) {
75615       {
75616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75617       };
75618     } catch (Dali::DaliException e) {
75619       {
75620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75621       };
75622     } catch (...) {
75623       {
75624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75625       };
75626     }
75627   }
75628
75629   jresult = result;
75630   return jresult;
75631 }
75632
75633
75634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75636   bool arg2 ;
75637
75638   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75639   arg2 = jarg2 ? true : false;
75640   {
75641     try {
75642       (arg1)->SetAxisAutoLock(arg2);
75643     } catch (std::out_of_range& e) {
75644       {
75645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75646       };
75647     } catch (std::exception& e) {
75648       {
75649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75650       };
75651     } catch (Dali::DaliException e) {
75652       {
75653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75654       };
75655     } catch (...) {
75656       {
75657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75658       };
75659     }
75660   }
75661
75662 }
75663
75664
75665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75666   float jresult ;
75667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75668   float result;
75669
75670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75671   {
75672     try {
75673       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75674     } catch (std::out_of_range& e) {
75675       {
75676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75677       };
75678     } catch (std::exception& e) {
75679       {
75680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75681       };
75682     } catch (Dali::DaliException e) {
75683       {
75684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75685       };
75686     } catch (...) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75689       };
75690     }
75691   }
75692
75693   jresult = result;
75694   return jresult;
75695 }
75696
75697
75698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75700   float arg2 ;
75701
75702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75703   arg2 = (float)jarg2;
75704   {
75705     try {
75706       (arg1)->SetAxisAutoLockGradient(arg2);
75707     } catch (std::out_of_range& e) {
75708       {
75709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75710       };
75711     } catch (std::exception& e) {
75712       {
75713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75714       };
75715     } catch (Dali::DaliException e) {
75716       {
75717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75718       };
75719     } catch (...) {
75720       {
75721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75722       };
75723     }
75724   }
75725
75726 }
75727
75728
75729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75730   float jresult ;
75731   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75732   float result;
75733
75734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75735   {
75736     try {
75737       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75738     } catch (std::out_of_range& e) {
75739       {
75740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75741       };
75742     } catch (std::exception& e) {
75743       {
75744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75745       };
75746     } catch (Dali::DaliException e) {
75747       {
75748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75749       };
75750     } catch (...) {
75751       {
75752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75753       };
75754     }
75755   }
75756
75757   jresult = result;
75758   return jresult;
75759 }
75760
75761
75762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75764   float arg2 ;
75765
75766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75767   arg2 = (float)jarg2;
75768   {
75769     try {
75770       (arg1)->SetFrictionCoefficient(arg2);
75771     } catch (std::out_of_range& e) {
75772       {
75773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75774       };
75775     } catch (std::exception& e) {
75776       {
75777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75778       };
75779     } catch (Dali::DaliException e) {
75780       {
75781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75782       };
75783     } catch (...) {
75784       {
75785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75786       };
75787     }
75788   }
75789
75790 }
75791
75792
75793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75794   float jresult ;
75795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75796   float result;
75797
75798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75799   {
75800     try {
75801       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75802     } catch (std::out_of_range& e) {
75803       {
75804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75805       };
75806     } catch (std::exception& e) {
75807       {
75808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75809       };
75810     } catch (Dali::DaliException e) {
75811       {
75812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75813       };
75814     } catch (...) {
75815       {
75816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75817       };
75818     }
75819   }
75820
75821   jresult = result;
75822   return jresult;
75823 }
75824
75825
75826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75828   float arg2 ;
75829
75830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75831   arg2 = (float)jarg2;
75832   {
75833     try {
75834       (arg1)->SetFlickSpeedCoefficient(arg2);
75835     } catch (std::out_of_range& e) {
75836       {
75837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75838       };
75839     } catch (std::exception& e) {
75840       {
75841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75842       };
75843     } catch (Dali::DaliException e) {
75844       {
75845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75846       };
75847     } catch (...) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75850       };
75851     }
75852   }
75853
75854 }
75855
75856
75857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75858   void * jresult ;
75859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75860   Dali::Vector2 result;
75861
75862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75863   {
75864     try {
75865       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75866     } catch (std::out_of_range& e) {
75867       {
75868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75869       };
75870     } catch (std::exception& e) {
75871       {
75872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75873       };
75874     } catch (Dali::DaliException e) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75877       };
75878     } catch (...) {
75879       {
75880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75881       };
75882     }
75883   }
75884
75885   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75886   return jresult;
75887 }
75888
75889
75890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75892   Dali::Vector2 *arg2 = 0 ;
75893
75894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75895   arg2 = (Dali::Vector2 *)jarg2;
75896   if (!arg2) {
75897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75898     return ;
75899   }
75900   {
75901     try {
75902       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75903     } catch (std::out_of_range& e) {
75904       {
75905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75906       };
75907     } catch (std::exception& e) {
75908       {
75909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75910       };
75911     } catch (Dali::DaliException e) {
75912       {
75913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75914       };
75915     } catch (...) {
75916       {
75917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75918       };
75919     }
75920   }
75921
75922 }
75923
75924
75925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75926   float jresult ;
75927   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75928   float result;
75929
75930   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75931   {
75932     try {
75933       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75934     } catch (std::out_of_range& e) {
75935       {
75936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75937       };
75938     } catch (std::exception& e) {
75939       {
75940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75941       };
75942     } catch (Dali::DaliException e) {
75943       {
75944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75945       };
75946     } catch (...) {
75947       {
75948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75949       };
75950     }
75951   }
75952
75953   jresult = result;
75954   return jresult;
75955 }
75956
75957
75958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75960   float arg2 ;
75961
75962   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75963   arg2 = (float)jarg2;
75964   {
75965     try {
75966       (arg1)->SetMinimumSpeedForFlick(arg2);
75967     } catch (std::out_of_range& e) {
75968       {
75969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75970       };
75971     } catch (std::exception& e) {
75972       {
75973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75974       };
75975     } catch (Dali::DaliException e) {
75976       {
75977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75978       };
75979     } catch (...) {
75980       {
75981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75982       };
75983     }
75984   }
75985
75986 }
75987
75988
75989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75990   float jresult ;
75991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75992   float result;
75993
75994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75995   {
75996     try {
75997       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75998     } catch (std::out_of_range& e) {
75999       {
76000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76001       };
76002     } catch (std::exception& e) {
76003       {
76004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76005       };
76006     } catch (Dali::DaliException e) {
76007       {
76008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76009       };
76010     } catch (...) {
76011       {
76012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76013       };
76014     }
76015   }
76016
76017   jresult = result;
76018   return jresult;
76019 }
76020
76021
76022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
76023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76024   float arg2 ;
76025
76026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76027   arg2 = (float)jarg2;
76028   {
76029     try {
76030       (arg1)->SetMaxFlickSpeed(arg2);
76031     } catch (std::out_of_range& e) {
76032       {
76033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76034       };
76035     } catch (std::exception& e) {
76036       {
76037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76038       };
76039     } catch (Dali::DaliException e) {
76040       {
76041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76042       };
76043     } catch (...) {
76044       {
76045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76046       };
76047     }
76048   }
76049
76050 }
76051
76052
76053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
76054   void * jresult ;
76055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76056   Dali::Vector2 result;
76057
76058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76059   {
76060     try {
76061       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
76062     } catch (std::out_of_range& e) {
76063       {
76064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (std::exception& e) {
76067       {
76068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76069       };
76070     } catch (Dali::DaliException e) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76073       };
76074     } catch (...) {
76075       {
76076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76077       };
76078     }
76079   }
76080
76081   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76082   return jresult;
76083 }
76084
76085
76086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
76087   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76088   Dali::Vector2 arg2 ;
76089   Dali::Vector2 *argp2 ;
76090
76091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76092   argp2 = (Dali::Vector2 *)jarg2;
76093   if (!argp2) {
76094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
76095     return ;
76096   }
76097   arg2 = *argp2;
76098   {
76099     try {
76100       (arg1)->SetWheelScrollDistanceStep(arg2);
76101     } catch (std::out_of_range& e) {
76102       {
76103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76104       };
76105     } catch (std::exception& e) {
76106       {
76107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76108       };
76109     } catch (Dali::DaliException e) {
76110       {
76111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76112       };
76113     } catch (...) {
76114       {
76115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76116       };
76117     }
76118   }
76119
76120 }
76121
76122
76123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
76124   void * jresult ;
76125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76126   Dali::Vector2 result;
76127
76128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76129   {
76130     try {
76131       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
76132     } catch (std::out_of_range& e) {
76133       {
76134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76135       };
76136     } catch (std::exception& e) {
76137       {
76138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76139       };
76140     } catch (Dali::DaliException e) {
76141       {
76142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76143       };
76144     } catch (...) {
76145       {
76146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76147       };
76148     }
76149   }
76150
76151   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76152   return jresult;
76153 }
76154
76155
76156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
76157   unsigned int jresult ;
76158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76159   unsigned int result;
76160
76161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76162   {
76163     try {
76164       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
76165     } catch (std::out_of_range& e) {
76166       {
76167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (std::exception& e) {
76170       {
76171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76172       };
76173     } catch (Dali::DaliException e) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76180       };
76181     }
76182   }
76183
76184   jresult = result;
76185   return jresult;
76186 }
76187
76188
76189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76191   Dali::Vector2 *arg2 = 0 ;
76192
76193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76194   arg2 = (Dali::Vector2 *)jarg2;
76195   if (!arg2) {
76196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76197     return ;
76198   }
76199   {
76200     try {
76201       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76202     } catch (std::out_of_range& e) {
76203       {
76204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76205       };
76206     } catch (std::exception& e) {
76207       {
76208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76209       };
76210     } catch (Dali::DaliException e) {
76211       {
76212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76213       };
76214     } catch (...) {
76215       {
76216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76217       };
76218     }
76219   }
76220
76221 }
76222
76223
76224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76225   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76226   Dali::Vector2 *arg2 = 0 ;
76227   float arg3 ;
76228
76229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76230   arg2 = (Dali::Vector2 *)jarg2;
76231   if (!arg2) {
76232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76233     return ;
76234   }
76235   arg3 = (float)jarg3;
76236   {
76237     try {
76238       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76239     } catch (std::out_of_range& e) {
76240       {
76241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76242       };
76243     } catch (std::exception& e) {
76244       {
76245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76246       };
76247     } catch (Dali::DaliException e) {
76248       {
76249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76250       };
76251     } catch (...) {
76252       {
76253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76254       };
76255     }
76256   }
76257
76258 }
76259
76260
76261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76262   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76263   Dali::Vector2 *arg2 = 0 ;
76264   float arg3 ;
76265   Dali::AlphaFunction arg4 ;
76266   Dali::AlphaFunction *argp4 ;
76267
76268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76269   arg2 = (Dali::Vector2 *)jarg2;
76270   if (!arg2) {
76271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76272     return ;
76273   }
76274   arg3 = (float)jarg3;
76275   argp4 = (Dali::AlphaFunction *)jarg4;
76276   if (!argp4) {
76277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76278     return ;
76279   }
76280   arg4 = *argp4;
76281   {
76282     try {
76283       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76284     } catch (std::out_of_range& e) {
76285       {
76286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76287       };
76288     } catch (std::exception& e) {
76289       {
76290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76291       };
76292     } catch (Dali::DaliException e) {
76293       {
76294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76295       };
76296     } catch (...) {
76297       {
76298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76299       };
76300     }
76301   }
76302
76303 }
76304
76305
76306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76307   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76308   Dali::Vector2 *arg2 = 0 ;
76309   float arg3 ;
76310   Dali::Toolkit::DirectionBias arg4 ;
76311   Dali::Toolkit::DirectionBias arg5 ;
76312
76313   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76314   arg2 = (Dali::Vector2 *)jarg2;
76315   if (!arg2) {
76316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76317     return ;
76318   }
76319   arg3 = (float)jarg3;
76320   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76321   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76322   {
76323     try {
76324       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76325     } catch (std::out_of_range& e) {
76326       {
76327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76328       };
76329     } catch (std::exception& e) {
76330       {
76331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76332       };
76333     } catch (Dali::DaliException e) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76336       };
76337     } catch (...) {
76338       {
76339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76340       };
76341     }
76342   }
76343
76344 }
76345
76346
76347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76348   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76349   Dali::Vector2 *arg2 = 0 ;
76350   float arg3 ;
76351   Dali::AlphaFunction arg4 ;
76352   Dali::Toolkit::DirectionBias arg5 ;
76353   Dali::Toolkit::DirectionBias arg6 ;
76354   Dali::AlphaFunction *argp4 ;
76355
76356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76357   arg2 = (Dali::Vector2 *)jarg2;
76358   if (!arg2) {
76359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76360     return ;
76361   }
76362   arg3 = (float)jarg3;
76363   argp4 = (Dali::AlphaFunction *)jarg4;
76364   if (!argp4) {
76365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76366     return ;
76367   }
76368   arg4 = *argp4;
76369   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76370   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76371   {
76372     try {
76373       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76381       };
76382     } catch (Dali::DaliException e) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76385       };
76386     } catch (...) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76389       };
76390     }
76391   }
76392
76393 }
76394
76395
76396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76398   unsigned int arg2 ;
76399
76400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76401   arg2 = (unsigned int)jarg2;
76402   {
76403     try {
76404       (arg1)->ScrollTo(arg2);
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 (Dali::DaliException e) {
76414       {
76415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76416       };
76417     } catch (...) {
76418       {
76419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76420       };
76421     }
76422   }
76423
76424 }
76425
76426
76427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76428   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76429   unsigned int arg2 ;
76430   float arg3 ;
76431
76432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76433   arg2 = (unsigned int)jarg2;
76434   arg3 = (float)jarg3;
76435   {
76436     try {
76437       (arg1)->ScrollTo(arg2,arg3);
76438     } catch (std::out_of_range& e) {
76439       {
76440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76441       };
76442     } catch (std::exception& e) {
76443       {
76444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76445       };
76446     } catch (Dali::DaliException e) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76449       };
76450     } catch (...) {
76451       {
76452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76453       };
76454     }
76455   }
76456
76457 }
76458
76459
76460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76462   unsigned int arg2 ;
76463   float arg3 ;
76464   Dali::Toolkit::DirectionBias arg4 ;
76465
76466   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76467   arg2 = (unsigned int)jarg2;
76468   arg3 = (float)jarg3;
76469   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76470   {
76471     try {
76472       (arg1)->ScrollTo(arg2,arg3,arg4);
76473     } catch (std::out_of_range& e) {
76474       {
76475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (std::exception& e) {
76478       {
76479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76480       };
76481     } catch (Dali::DaliException e) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76484       };
76485     } catch (...) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76488       };
76489     }
76490   }
76491
76492 }
76493
76494
76495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76497   Dali::Actor *arg2 = 0 ;
76498
76499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76500   arg2 = (Dali::Actor *)jarg2;
76501   if (!arg2) {
76502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76503     return ;
76504   }
76505   {
76506     try {
76507       (arg1)->ScrollTo(*arg2);
76508     } catch (std::out_of_range& e) {
76509       {
76510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (std::exception& e) {
76513       {
76514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76515       };
76516     } catch (Dali::DaliException e) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76519       };
76520     } catch (...) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76523       };
76524     }
76525   }
76526
76527 }
76528
76529
76530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76532   Dali::Actor *arg2 = 0 ;
76533   float arg3 ;
76534
76535   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76536   arg2 = (Dali::Actor *)jarg2;
76537   if (!arg2) {
76538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76539     return ;
76540   }
76541   arg3 = (float)jarg3;
76542   {
76543     try {
76544       (arg1)->ScrollTo(*arg2,arg3);
76545     } catch (std::out_of_range& e) {
76546       {
76547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76548       };
76549     } catch (std::exception& e) {
76550       {
76551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76552       };
76553     } catch (Dali::DaliException e) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76560       };
76561     }
76562   }
76563
76564 }
76565
76566
76567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76568   unsigned int jresult ;
76569   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76570   bool result;
76571
76572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76573   {
76574     try {
76575       result = (bool)(arg1)->ScrollToSnapPoint();
76576     } catch (std::out_of_range& e) {
76577       {
76578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76579       };
76580     } catch (std::exception& e) {
76581       {
76582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76583       };
76584     } catch (Dali::DaliException e) {
76585       {
76586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76587       };
76588     } catch (...) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76591       };
76592     }
76593   }
76594
76595   jresult = result;
76596   return jresult;
76597 }
76598
76599
76600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76602   Dali::Constraint arg2 ;
76603   Dali::Constraint *argp2 ;
76604
76605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76606   argp2 = (Dali::Constraint *)jarg2;
76607   if (!argp2) {
76608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76609     return ;
76610   }
76611   arg2 = *argp2;
76612   {
76613     try {
76614       (arg1)->ApplyConstraintToChildren(arg2);
76615     } catch (std::out_of_range& e) {
76616       {
76617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76618       };
76619     } catch (std::exception& e) {
76620       {
76621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76622       };
76623     } catch (Dali::DaliException e) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76626       };
76627     } catch (...) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76630       };
76631     }
76632   }
76633
76634 }
76635
76636
76637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76639
76640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76641   {
76642     try {
76643       (arg1)->RemoveConstraintsFromChildren();
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76659       };
76660     }
76661   }
76662
76663 }
76664
76665
76666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76668   Dali::Toolkit::ScrollViewEffect arg2 ;
76669   Dali::Toolkit::ScrollViewEffect *argp2 ;
76670
76671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76672   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76673   if (!argp2) {
76674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76675     return ;
76676   }
76677   arg2 = *argp2;
76678   {
76679     try {
76680       (arg1)->ApplyEffect(arg2);
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76688       };
76689     } catch (Dali::DaliException e) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76692       };
76693     } catch (...) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76696       };
76697     }
76698   }
76699
76700 }
76701
76702
76703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76705   Dali::Toolkit::ScrollViewEffect arg2 ;
76706   Dali::Toolkit::ScrollViewEffect *argp2 ;
76707
76708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76709   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76710   if (!argp2) {
76711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76712     return ;
76713   }
76714   arg2 = *argp2;
76715   {
76716     try {
76717       (arg1)->RemoveEffect(arg2);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76725       };
76726     } catch (Dali::DaliException e) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76729       };
76730     } catch (...) {
76731       {
76732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76733       };
76734     }
76735   }
76736
76737 }
76738
76739
76740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76742
76743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76744   {
76745     try {
76746       (arg1)->RemoveAllEffects();
76747     } catch (std::out_of_range& e) {
76748       {
76749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76750       };
76751     } catch (std::exception& e) {
76752       {
76753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76754       };
76755     } catch (Dali::DaliException e) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76758       };
76759     } catch (...) {
76760       {
76761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76762       };
76763     }
76764   }
76765
76766 }
76767
76768
76769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76771   Dali::Actor arg2 ;
76772   Dali::Actor *argp2 ;
76773
76774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76775   argp2 = (Dali::Actor *)jarg2;
76776   if (!argp2) {
76777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76778     return ;
76779   }
76780   arg2 = *argp2;
76781   {
76782     try {
76783       (arg1)->BindActor(arg2);
76784     } catch (std::out_of_range& e) {
76785       {
76786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76787       };
76788     } catch (std::exception& e) {
76789       {
76790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76791       };
76792     } catch (Dali::DaliException e) {
76793       {
76794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76795       };
76796     } catch (...) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76799       };
76800     }
76801   }
76802
76803 }
76804
76805
76806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76808   Dali::Actor arg2 ;
76809   Dali::Actor *argp2 ;
76810
76811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76812   argp2 = (Dali::Actor *)jarg2;
76813   if (!argp2) {
76814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76815     return ;
76816   }
76817   arg2 = *argp2;
76818   {
76819     try {
76820       (arg1)->UnbindActor(arg2);
76821     } catch (std::out_of_range& e) {
76822       {
76823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76824       };
76825     } catch (std::exception& e) {
76826       {
76827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76828       };
76829     } catch (Dali::DaliException e) {
76830       {
76831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76832       };
76833     } catch (...) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76836       };
76837     }
76838   }
76839
76840 }
76841
76842
76843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76844   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76845   Dali::Radian arg2 ;
76846   Dali::Radian arg3 ;
76847   Dali::Radian *argp2 ;
76848   Dali::Radian *argp3 ;
76849
76850   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76851   argp2 = (Dali::Radian *)jarg2;
76852   if (!argp2) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76854     return ;
76855   }
76856   arg2 = *argp2;
76857   argp3 = (Dali::Radian *)jarg3;
76858   if (!argp3) {
76859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76860     return ;
76861   }
76862   arg3 = *argp3;
76863   {
76864     try {
76865       (arg1)->SetScrollingDirection(arg2,arg3);
76866     } catch (std::out_of_range& e) {
76867       {
76868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76869       };
76870     } catch (std::exception& e) {
76871       {
76872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76873       };
76874     } catch (Dali::DaliException e) {
76875       {
76876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76877       };
76878     } catch (...) {
76879       {
76880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76881       };
76882     }
76883   }
76884
76885 }
76886
76887
76888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76889   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76890   Dali::Radian arg2 ;
76891   Dali::Radian *argp2 ;
76892
76893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76894   argp2 = (Dali::Radian *)jarg2;
76895   if (!argp2) {
76896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76897     return ;
76898   }
76899   arg2 = *argp2;
76900   {
76901     try {
76902       (arg1)->SetScrollingDirection(arg2);
76903     } catch (std::out_of_range& e) {
76904       {
76905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76906       };
76907     } catch (std::exception& e) {
76908       {
76909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76910       };
76911     } catch (Dali::DaliException e) {
76912       {
76913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76914       };
76915     } catch (...) {
76916       {
76917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76918       };
76919     }
76920   }
76921
76922 }
76923
76924
76925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76927   Dali::Radian arg2 ;
76928   Dali::Radian *argp2 ;
76929
76930   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76931   argp2 = (Dali::Radian *)jarg2;
76932   if (!argp2) {
76933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76934     return ;
76935   }
76936   arg2 = *argp2;
76937   {
76938     try {
76939       (arg1)->RemoveScrollingDirection(arg2);
76940     } catch (std::out_of_range& e) {
76941       {
76942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76943       };
76944     } catch (std::exception& e) {
76945       {
76946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76947       };
76948     } catch (Dali::DaliException e) {
76949       {
76950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76951       };
76952     } catch (...) {
76953       {
76954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76955       };
76956     }
76957   }
76958
76959 }
76960
76961
76962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76963   void * jresult ;
76964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76965   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76966
76967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76968   {
76969     try {
76970       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
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 (Dali::DaliException e) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76982       };
76983     } catch (...) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76986       };
76987     }
76988   }
76989
76990   jresult = (void *)result;
76991   return jresult;
76992 }
76993
76994
76995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76996   int jresult ;
76997   int result;
76998
76999   result = (int)Dali::Toolkit::TableView::Property::ROWS;
77000   jresult = (int)result;
77001   return jresult;
77002 }
77003
77004
77005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
77006   int jresult ;
77007   int result;
77008
77009   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
77010   jresult = (int)result;
77011   return jresult;
77012 }
77013
77014
77015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
77016   int jresult ;
77017   int result;
77018
77019   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
77020   jresult = (int)result;
77021   return jresult;
77022 }
77023
77024
77025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
77026   int jresult ;
77027   int result;
77028
77029   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
77030   jresult = (int)result;
77031   return jresult;
77032 }
77033
77034
77035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
77036   int jresult ;
77037   int result;
77038
77039   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
77040   jresult = (int)result;
77041   return jresult;
77042 }
77043
77044
77045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
77046   void * jresult ;
77047   Dali::Toolkit::TableView::Property *result = 0 ;
77048
77049   {
77050     try {
77051       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
77052     } catch (std::out_of_range& e) {
77053       {
77054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77055       };
77056     } catch (std::exception& e) {
77057       {
77058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77059       };
77060     } catch (Dali::DaliException e) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77063       };
77064     } catch (...) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77067       };
77068     }
77069   }
77070
77071   jresult = (void *)result;
77072   return jresult;
77073 }
77074
77075
77076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
77077   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
77078
77079   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
77080   {
77081     try {
77082       delete arg1;
77083     } catch (std::out_of_range& e) {
77084       {
77085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77086       };
77087     } catch (std::exception& e) {
77088       {
77089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77090       };
77091     } catch (Dali::DaliException e) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77098       };
77099     }
77100   }
77101
77102 }
77103
77104
77105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
77106   int jresult ;
77107   int result;
77108
77109   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
77110   jresult = (int)result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
77116   int jresult ;
77117   int result;
77118
77119   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
77120   jresult = (int)result;
77121   return jresult;
77122 }
77123
77124
77125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
77126   int jresult ;
77127   int result;
77128
77129   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
77130   jresult = (int)result;
77131   return jresult;
77132 }
77133
77134
77135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
77136   int jresult ;
77137   int result;
77138
77139   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
77140   jresult = (int)result;
77141   return jresult;
77142 }
77143
77144
77145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
77146   int jresult ;
77147   int result;
77148
77149   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
77150   jresult = (int)result;
77151   return jresult;
77152 }
77153
77154
77155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
77156   void * jresult ;
77157   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
77158
77159   {
77160     try {
77161       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
77162     } catch (std::out_of_range& e) {
77163       {
77164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (std::exception& e) {
77167       {
77168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77169       };
77170     } catch (Dali::DaliException e) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77173       };
77174     } catch (...) {
77175       {
77176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77177       };
77178     }
77179   }
77180
77181   jresult = (void *)result;
77182   return jresult;
77183 }
77184
77185
77186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77187   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77188
77189   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77190   {
77191     try {
77192       delete arg1;
77193     } catch (std::out_of_range& e) {
77194       {
77195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (std::exception& e) {
77198       {
77199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77200       };
77201     } catch (Dali::DaliException e) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77204       };
77205     } catch (...) {
77206       {
77207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77208       };
77209     }
77210   }
77211
77212 }
77213
77214
77215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77216   void * jresult ;
77217   unsigned int arg1 ;
77218   unsigned int arg2 ;
77219   unsigned int arg3 ;
77220   unsigned int arg4 ;
77221   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77222
77223   arg1 = (unsigned int)jarg1;
77224   arg2 = (unsigned int)jarg2;
77225   arg3 = (unsigned int)jarg3;
77226   arg4 = (unsigned int)jarg4;
77227   {
77228     try {
77229       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77230     } catch (std::out_of_range& e) {
77231       {
77232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77233       };
77234     } catch (std::exception& e) {
77235       {
77236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77237       };
77238     } catch (Dali::DaliException e) {
77239       {
77240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77241       };
77242     } catch (...) {
77243       {
77244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77245       };
77246     }
77247   }
77248
77249   jresult = (void *)result;
77250   return jresult;
77251 }
77252
77253
77254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77255   void * jresult ;
77256   unsigned int arg1 ;
77257   unsigned int arg2 ;
77258   unsigned int arg3 ;
77259   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77260
77261   arg1 = (unsigned int)jarg1;
77262   arg2 = (unsigned int)jarg2;
77263   arg3 = (unsigned int)jarg3;
77264   {
77265     try {
77266       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77267     } catch (std::out_of_range& e) {
77268       {
77269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77270       };
77271     } catch (std::exception& e) {
77272       {
77273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77274       };
77275     } catch (Dali::DaliException e) {
77276       {
77277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77278       };
77279     } catch (...) {
77280       {
77281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77282       };
77283     }
77284   }
77285
77286   jresult = (void *)result;
77287   return jresult;
77288 }
77289
77290
77291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77292   void * jresult ;
77293   unsigned int arg1 ;
77294   unsigned int arg2 ;
77295   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77296
77297   arg1 = (unsigned int)jarg1;
77298   arg2 = (unsigned int)jarg2;
77299   {
77300     try {
77301       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77302     } catch (std::out_of_range& e) {
77303       {
77304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77305       };
77306     } catch (std::exception& e) {
77307       {
77308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77309       };
77310     } catch (Dali::DaliException e) {
77311       {
77312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77313       };
77314     } catch (...) {
77315       {
77316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77317       };
77318     }
77319   }
77320
77321   jresult = (void *)result;
77322   return jresult;
77323 }
77324
77325
77326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77327   void * jresult ;
77328   unsigned int arg1 ;
77329   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77330
77331   arg1 = (unsigned int)jarg1;
77332   {
77333     try {
77334       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77335     } catch (std::out_of_range& e) {
77336       {
77337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77338       };
77339     } catch (std::exception& e) {
77340       {
77341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77342       };
77343     } catch (Dali::DaliException e) {
77344       {
77345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77346       };
77347     } catch (...) {
77348       {
77349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77350       };
77351     }
77352   }
77353
77354   jresult = (void *)result;
77355   return jresult;
77356 }
77357
77358
77359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77360   void * jresult ;
77361   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77362
77363   {
77364     try {
77365       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77373       };
77374     } catch (Dali::DaliException e) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77377       };
77378     } catch (...) {
77379       {
77380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77381       };
77382     }
77383   }
77384
77385   jresult = (void *)result;
77386   return jresult;
77387 }
77388
77389
77390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77391   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77392   unsigned int arg2 ;
77393
77394   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77395   arg2 = (unsigned int)jarg2;
77396   if (arg1) (arg1)->rowIndex = arg2;
77397 }
77398
77399
77400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77401   unsigned int jresult ;
77402   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77403   unsigned int result;
77404
77405   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77406   result = (unsigned int) ((arg1)->rowIndex);
77407   jresult = result;
77408   return jresult;
77409 }
77410
77411
77412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77413   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77414   unsigned int arg2 ;
77415
77416   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77417   arg2 = (unsigned int)jarg2;
77418   if (arg1) (arg1)->columnIndex = arg2;
77419 }
77420
77421
77422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77423   unsigned int jresult ;
77424   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77425   unsigned int result;
77426
77427   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77428   result = (unsigned int) ((arg1)->columnIndex);
77429   jresult = result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77435   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77436   unsigned int arg2 ;
77437
77438   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77439   arg2 = (unsigned int)jarg2;
77440   if (arg1) (arg1)->rowSpan = arg2;
77441 }
77442
77443
77444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77445   unsigned int jresult ;
77446   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77447   unsigned int result;
77448
77449   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77450   result = (unsigned int) ((arg1)->rowSpan);
77451   jresult = result;
77452   return jresult;
77453 }
77454
77455
77456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77457   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77458   unsigned int arg2 ;
77459
77460   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77461   arg2 = (unsigned int)jarg2;
77462   if (arg1) (arg1)->columnSpan = arg2;
77463 }
77464
77465
77466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77467   unsigned int jresult ;
77468   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77469   unsigned int result;
77470
77471   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77472   result = (unsigned int) ((arg1)->columnSpan);
77473   jresult = result;
77474   return jresult;
77475 }
77476
77477
77478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77479   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77480
77481   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77482   {
77483     try {
77484       delete arg1;
77485     } catch (std::out_of_range& e) {
77486       {
77487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77488       };
77489     } catch (std::exception& e) {
77490       {
77491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77492       };
77493     } catch (Dali::DaliException e) {
77494       {
77495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77496       };
77497     } catch (...) {
77498       {
77499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77500       };
77501     }
77502   }
77503
77504 }
77505
77506
77507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77508   void * jresult ;
77509   Dali::Toolkit::TableView *result = 0 ;
77510
77511   {
77512     try {
77513       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77514     } catch (std::out_of_range& e) {
77515       {
77516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77517       };
77518     } catch (std::exception& e) {
77519       {
77520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77521       };
77522     } catch (Dali::DaliException e) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77525       };
77526     } catch (...) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77529       };
77530     }
77531   }
77532
77533   jresult = (void *)result;
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77539   void * jresult ;
77540   Dali::Toolkit::TableView *arg1 = 0 ;
77541   Dali::Toolkit::TableView *result = 0 ;
77542
77543   arg1 = (Dali::Toolkit::TableView *)jarg1;
77544   if (!arg1) {
77545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77546     return 0;
77547   }
77548   {
77549     try {
77550       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77551     } catch (std::out_of_range& e) {
77552       {
77553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77554       };
77555     } catch (std::exception& e) {
77556       {
77557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77558       };
77559     } catch (Dali::DaliException e) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77562       };
77563     } catch (...) {
77564       {
77565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77566       };
77567     }
77568   }
77569
77570   jresult = (void *)result;
77571   return jresult;
77572 }
77573
77574
77575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77576   void * jresult ;
77577   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77578   Dali::Toolkit::TableView *arg2 = 0 ;
77579   Dali::Toolkit::TableView *result = 0 ;
77580
77581   arg1 = (Dali::Toolkit::TableView *)jarg1;
77582   arg2 = (Dali::Toolkit::TableView *)jarg2;
77583   if (!arg2) {
77584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77585     return 0;
77586   }
77587   {
77588     try {
77589       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77590     } catch (std::out_of_range& e) {
77591       {
77592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77593       };
77594     } catch (std::exception& e) {
77595       {
77596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77597       };
77598     } catch (Dali::DaliException e) {
77599       {
77600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77601       };
77602     } catch (...) {
77603       {
77604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77605       };
77606     }
77607   }
77608
77609   jresult = (void *)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77615   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77616
77617   arg1 = (Dali::Toolkit::TableView *)jarg1;
77618   {
77619     try {
77620       delete arg1;
77621     } catch (std::out_of_range& e) {
77622       {
77623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77624       };
77625     } catch (std::exception& e) {
77626       {
77627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77628       };
77629     } catch (Dali::DaliException e) {
77630       {
77631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77632       };
77633     } catch (...) {
77634       {
77635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77636       };
77637     }
77638   }
77639
77640 }
77641
77642
77643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77644   void * jresult ;
77645   unsigned int arg1 ;
77646   unsigned int arg2 ;
77647   Dali::Toolkit::TableView result;
77648
77649   arg1 = (unsigned int)jarg1;
77650   arg2 = (unsigned int)jarg2;
77651   {
77652     try {
77653       result = Dali::Toolkit::TableView::New(arg1,arg2);
77654     } catch (std::out_of_range& e) {
77655       {
77656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77657       };
77658     } catch (std::exception& e) {
77659       {
77660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77661       };
77662     } catch (Dali::DaliException e) {
77663       {
77664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77665       };
77666     } catch (...) {
77667       {
77668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77669       };
77670     }
77671   }
77672
77673   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77674   return jresult;
77675 }
77676
77677
77678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77679   void * jresult ;
77680   Dali::BaseHandle arg1 ;
77681   Dali::BaseHandle *argp1 ;
77682   Dali::Toolkit::TableView result;
77683
77684   argp1 = (Dali::BaseHandle *)jarg1;
77685   if (!argp1) {
77686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77687     return 0;
77688   }
77689   arg1 = *argp1;
77690   {
77691     try {
77692       result = Dali::Toolkit::TableView::DownCast(arg1);
77693     } catch (std::out_of_range& e) {
77694       {
77695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77696       };
77697     } catch (std::exception& e) {
77698       {
77699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77700       };
77701     } catch (Dali::DaliException e) {
77702       {
77703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77704       };
77705     } catch (...) {
77706       {
77707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77708       };
77709     }
77710   }
77711
77712   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77713   return jresult;
77714 }
77715
77716
77717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77718   unsigned int jresult ;
77719   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77720   Dali::Actor arg2 ;
77721   Dali::Toolkit::TableView::CellPosition arg3 ;
77722   Dali::Actor *argp2 ;
77723   Dali::Toolkit::TableView::CellPosition *argp3 ;
77724   bool result;
77725
77726   arg1 = (Dali::Toolkit::TableView *)jarg1;
77727   argp2 = (Dali::Actor *)jarg2;
77728   if (!argp2) {
77729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77730     return 0;
77731   }
77732   arg2 = *argp2;
77733   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77734   if (!argp3) {
77735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77736     return 0;
77737   }
77738   arg3 = *argp3;
77739   {
77740     try {
77741       result = (bool)(arg1)->AddChild(arg2,arg3);
77742     } catch (std::out_of_range& e) {
77743       {
77744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77745       };
77746     } catch (std::exception& e) {
77747       {
77748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77749       };
77750     } catch (Dali::DaliException e) {
77751       {
77752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77753       };
77754     } catch (...) {
77755       {
77756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77757       };
77758     }
77759   }
77760
77761   jresult = result;
77762   return jresult;
77763 }
77764
77765
77766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77767   void * jresult ;
77768   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77769   Dali::Toolkit::TableView::CellPosition arg2 ;
77770   Dali::Toolkit::TableView::CellPosition *argp2 ;
77771   Dali::Actor result;
77772
77773   arg1 = (Dali::Toolkit::TableView *)jarg1;
77774   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77775   if (!argp2) {
77776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77777     return 0;
77778   }
77779   arg2 = *argp2;
77780   {
77781     try {
77782       result = (arg1)->GetChildAt(arg2);
77783     } catch (std::out_of_range& e) {
77784       {
77785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (std::exception& e) {
77788       {
77789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77790       };
77791     } catch (Dali::DaliException e) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77794       };
77795     } catch (...) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77798       };
77799     }
77800   }
77801
77802   jresult = new Dali::Actor((const Dali::Actor &)result);
77803   return jresult;
77804 }
77805
77806
77807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77808   void * jresult ;
77809   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77810   Dali::Toolkit::TableView::CellPosition arg2 ;
77811   Dali::Toolkit::TableView::CellPosition *argp2 ;
77812   Dali::Actor result;
77813
77814   arg1 = (Dali::Toolkit::TableView *)jarg1;
77815   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77816   if (!argp2) {
77817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77818     return 0;
77819   }
77820   arg2 = *argp2;
77821   {
77822     try {
77823       result = (arg1)->RemoveChildAt(arg2);
77824     } catch (std::out_of_range& e) {
77825       {
77826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77827       };
77828     } catch (std::exception& e) {
77829       {
77830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77831       };
77832     } catch (Dali::DaliException e) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77835       };
77836     } catch (...) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77839       };
77840     }
77841   }
77842
77843   jresult = new Dali::Actor((const Dali::Actor &)result);
77844   return jresult;
77845 }
77846
77847
77848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77849   unsigned int jresult ;
77850   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77851   Dali::Actor arg2 ;
77852   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77853   Dali::Actor *argp2 ;
77854   bool result;
77855
77856   arg1 = (Dali::Toolkit::TableView *)jarg1;
77857   argp2 = (Dali::Actor *)jarg2;
77858   if (!argp2) {
77859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77860     return 0;
77861   }
77862   arg2 = *argp2;
77863   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77864   if (!arg3) {
77865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77866     return 0;
77867   }
77868   {
77869     try {
77870       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77871     } catch (std::out_of_range& e) {
77872       {
77873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77874       };
77875     } catch (std::exception& e) {
77876       {
77877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77878       };
77879     } catch (Dali::DaliException e) {
77880       {
77881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77882       };
77883     } catch (...) {
77884       {
77885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77886       };
77887     }
77888   }
77889
77890   jresult = result;
77891   return jresult;
77892 }
77893
77894
77895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77896   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77897   unsigned int arg2 ;
77898
77899   arg1 = (Dali::Toolkit::TableView *)jarg1;
77900   arg2 = (unsigned int)jarg2;
77901   {
77902     try {
77903       (arg1)->InsertRow(arg2);
77904     } catch (std::out_of_range& e) {
77905       {
77906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77907       };
77908     } catch (std::exception& e) {
77909       {
77910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77911       };
77912     } catch (Dali::DaliException e) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77915       };
77916     } catch (...) {
77917       {
77918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77919       };
77920     }
77921   }
77922
77923 }
77924
77925
77926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77927   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77928   unsigned int arg2 ;
77929
77930   arg1 = (Dali::Toolkit::TableView *)jarg1;
77931   arg2 = (unsigned int)jarg2;
77932   {
77933     try {
77934       (arg1)->DeleteRow(arg2);
77935     } catch (std::out_of_range& e) {
77936       {
77937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77938       };
77939     } catch (std::exception& e) {
77940       {
77941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77942       };
77943     } catch (Dali::DaliException e) {
77944       {
77945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77946       };
77947     } catch (...) {
77948       {
77949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77950       };
77951     }
77952   }
77953
77954 }
77955
77956
77957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77958   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77959   unsigned int arg2 ;
77960   std::vector< Dali::Actor > *arg3 = 0 ;
77961
77962   arg1 = (Dali::Toolkit::TableView *)jarg1;
77963   arg2 = (unsigned int)jarg2;
77964   arg3 = (std::vector< Dali::Actor > *)jarg3;
77965   if (!arg3) {
77966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77967     return ;
77968   }
77969   {
77970     try {
77971       (arg1)->DeleteRow(arg2,*arg3);
77972     } catch (std::out_of_range& e) {
77973       {
77974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77975       };
77976     } catch (std::exception& e) {
77977       {
77978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77979       };
77980     } catch (Dali::DaliException e) {
77981       {
77982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77983       };
77984     } catch (...) {
77985       {
77986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77987       };
77988     }
77989   }
77990
77991 }
77992
77993
77994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77995   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77996   unsigned int arg2 ;
77997
77998   arg1 = (Dali::Toolkit::TableView *)jarg1;
77999   arg2 = (unsigned int)jarg2;
78000   {
78001     try {
78002       (arg1)->InsertColumn(arg2);
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78010       };
78011     } catch (Dali::DaliException e) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78018       };
78019     }
78020   }
78021
78022 }
78023
78024
78025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
78026   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78027   unsigned int arg2 ;
78028
78029   arg1 = (Dali::Toolkit::TableView *)jarg1;
78030   arg2 = (unsigned int)jarg2;
78031   {
78032     try {
78033       (arg1)->DeleteColumn(arg2);
78034     } catch (std::out_of_range& e) {
78035       {
78036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78037       };
78038     } catch (std::exception& e) {
78039       {
78040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78041       };
78042     } catch (Dali::DaliException e) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78045       };
78046     } catch (...) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78049       };
78050     }
78051   }
78052
78053 }
78054
78055
78056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78057   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78058   unsigned int arg2 ;
78059   std::vector< Dali::Actor > *arg3 = 0 ;
78060
78061   arg1 = (Dali::Toolkit::TableView *)jarg1;
78062   arg2 = (unsigned int)jarg2;
78063   arg3 = (std::vector< Dali::Actor > *)jarg3;
78064   if (!arg3) {
78065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78066     return ;
78067   }
78068   {
78069     try {
78070       (arg1)->DeleteColumn(arg2,*arg3);
78071     } catch (std::out_of_range& e) {
78072       {
78073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78074       };
78075     } catch (std::exception& e) {
78076       {
78077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78078       };
78079     } catch (Dali::DaliException e) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78082       };
78083     } catch (...) {
78084       {
78085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78086       };
78087     }
78088   }
78089
78090 }
78091
78092
78093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
78094   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78095   unsigned int arg2 ;
78096   unsigned int arg3 ;
78097
78098   arg1 = (Dali::Toolkit::TableView *)jarg1;
78099   arg2 = (unsigned int)jarg2;
78100   arg3 = (unsigned int)jarg3;
78101   {
78102     try {
78103       (arg1)->Resize(arg2,arg3);
78104     } catch (std::out_of_range& e) {
78105       {
78106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78107       };
78108     } catch (std::exception& e) {
78109       {
78110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78111       };
78112     } catch (Dali::DaliException e) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78115       };
78116     } catch (...) {
78117       {
78118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78119       };
78120     }
78121   }
78122
78123 }
78124
78125
78126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
78127   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78128   unsigned int arg2 ;
78129   unsigned int arg3 ;
78130   std::vector< Dali::Actor > *arg4 = 0 ;
78131
78132   arg1 = (Dali::Toolkit::TableView *)jarg1;
78133   arg2 = (unsigned int)jarg2;
78134   arg3 = (unsigned int)jarg3;
78135   arg4 = (std::vector< Dali::Actor > *)jarg4;
78136   if (!arg4) {
78137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78138     return ;
78139   }
78140   {
78141     try {
78142       (arg1)->Resize(arg2,arg3,*arg4);
78143     } catch (std::out_of_range& e) {
78144       {
78145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78146       };
78147     } catch (std::exception& e) {
78148       {
78149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78150       };
78151     } catch (Dali::DaliException e) {
78152       {
78153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78158       };
78159     }
78160   }
78161
78162 }
78163
78164
78165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
78166   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78167   Dali::Size arg2 ;
78168   Dali::Size *argp2 ;
78169
78170   arg1 = (Dali::Toolkit::TableView *)jarg1;
78171   argp2 = (Dali::Size *)jarg2;
78172   if (!argp2) {
78173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78174     return ;
78175   }
78176   arg2 = *argp2;
78177   {
78178     try {
78179       (arg1)->SetCellPadding(arg2);
78180     } catch (std::out_of_range& e) {
78181       {
78182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78183       };
78184     } catch (std::exception& e) {
78185       {
78186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78187       };
78188     } catch (Dali::DaliException e) {
78189       {
78190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78191       };
78192     } catch (...) {
78193       {
78194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78195       };
78196     }
78197   }
78198
78199 }
78200
78201
78202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78203   void * jresult ;
78204   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78205   Dali::Size result;
78206
78207   arg1 = (Dali::Toolkit::TableView *)jarg1;
78208   {
78209     try {
78210       result = (arg1)->GetCellPadding();
78211     } catch (std::out_of_range& e) {
78212       {
78213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78214       };
78215     } catch (std::exception& e) {
78216       {
78217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78218       };
78219     } catch (Dali::DaliException e) {
78220       {
78221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78222       };
78223     } catch (...) {
78224       {
78225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78226       };
78227     }
78228   }
78229
78230   jresult = new Dali::Size((const Dali::Size &)result);
78231   return jresult;
78232 }
78233
78234
78235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78237   unsigned int arg2 ;
78238
78239   arg1 = (Dali::Toolkit::TableView *)jarg1;
78240   arg2 = (unsigned int)jarg2;
78241   {
78242     try {
78243       (arg1)->SetFitHeight(arg2);
78244     } catch (std::out_of_range& e) {
78245       {
78246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78247       };
78248     } catch (std::exception& e) {
78249       {
78250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78251       };
78252     } catch (Dali::DaliException e) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78255       };
78256     } catch (...) {
78257       {
78258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78259       };
78260     }
78261   }
78262
78263 }
78264
78265
78266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78267   unsigned int jresult ;
78268   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78269   unsigned int arg2 ;
78270   bool result;
78271
78272   arg1 = (Dali::Toolkit::TableView *)jarg1;
78273   arg2 = (unsigned int)jarg2;
78274   {
78275     try {
78276       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78277     } catch (std::out_of_range& e) {
78278       {
78279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78280       };
78281     } catch (std::exception& e) {
78282       {
78283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78284       };
78285     } catch (Dali::DaliException e) {
78286       {
78287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78288       };
78289     } catch (...) {
78290       {
78291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78292       };
78293     }
78294   }
78295
78296   jresult = result;
78297   return jresult;
78298 }
78299
78300
78301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78302   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78303   unsigned int arg2 ;
78304
78305   arg1 = (Dali::Toolkit::TableView *)jarg1;
78306   arg2 = (unsigned int)jarg2;
78307   {
78308     try {
78309       (arg1)->SetFitWidth(arg2);
78310     } catch (std::out_of_range& e) {
78311       {
78312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78313       };
78314     } catch (std::exception& e) {
78315       {
78316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78317       };
78318     } catch (Dali::DaliException e) {
78319       {
78320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78321       };
78322     } catch (...) {
78323       {
78324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78325       };
78326     }
78327   }
78328
78329 }
78330
78331
78332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78333   unsigned int jresult ;
78334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78335   unsigned int arg2 ;
78336   bool result;
78337
78338   arg1 = (Dali::Toolkit::TableView *)jarg1;
78339   arg2 = (unsigned int)jarg2;
78340   {
78341     try {
78342       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78343     } catch (std::out_of_range& e) {
78344       {
78345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78346       };
78347     } catch (std::exception& e) {
78348       {
78349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78350       };
78351     } catch (Dali::DaliException e) {
78352       {
78353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78354       };
78355     } catch (...) {
78356       {
78357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78358       };
78359     }
78360   }
78361
78362   jresult = result;
78363   return jresult;
78364 }
78365
78366
78367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78368   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78369   unsigned int arg2 ;
78370   float arg3 ;
78371
78372   arg1 = (Dali::Toolkit::TableView *)jarg1;
78373   arg2 = (unsigned int)jarg2;
78374   arg3 = (float)jarg3;
78375   {
78376     try {
78377       (arg1)->SetFixedHeight(arg2,arg3);
78378     } catch (std::out_of_range& e) {
78379       {
78380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78381       };
78382     } catch (std::exception& e) {
78383       {
78384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78385       };
78386     } catch (Dali::DaliException e) {
78387       {
78388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78389       };
78390     } catch (...) {
78391       {
78392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78393       };
78394     }
78395   }
78396
78397 }
78398
78399
78400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78401   float jresult ;
78402   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78403   unsigned int arg2 ;
78404   float result;
78405
78406   arg1 = (Dali::Toolkit::TableView *)jarg1;
78407   arg2 = (unsigned int)jarg2;
78408   {
78409     try {
78410       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78411     } catch (std::out_of_range& e) {
78412       {
78413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78414       };
78415     } catch (std::exception& e) {
78416       {
78417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78418       };
78419     } catch (Dali::DaliException e) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78422       };
78423     } catch (...) {
78424       {
78425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78426       };
78427     }
78428   }
78429
78430   jresult = result;
78431   return jresult;
78432 }
78433
78434
78435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78436   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78437   unsigned int arg2 ;
78438   float arg3 ;
78439
78440   arg1 = (Dali::Toolkit::TableView *)jarg1;
78441   arg2 = (unsigned int)jarg2;
78442   arg3 = (float)jarg3;
78443   {
78444     try {
78445       (arg1)->SetRelativeHeight(arg2,arg3);
78446     } catch (std::out_of_range& e) {
78447       {
78448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78449       };
78450     } catch (std::exception& e) {
78451       {
78452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78453       };
78454     } catch (Dali::DaliException e) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78457       };
78458     } catch (...) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78461       };
78462     }
78463   }
78464
78465 }
78466
78467
78468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78469   float jresult ;
78470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78471   unsigned int arg2 ;
78472   float result;
78473
78474   arg1 = (Dali::Toolkit::TableView *)jarg1;
78475   arg2 = (unsigned int)jarg2;
78476   {
78477     try {
78478       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78479     } catch (std::out_of_range& e) {
78480       {
78481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78482       };
78483     } catch (std::exception& e) {
78484       {
78485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78486       };
78487     } catch (Dali::DaliException e) {
78488       {
78489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78490       };
78491     } catch (...) {
78492       {
78493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78494       };
78495     }
78496   }
78497
78498   jresult = result;
78499   return jresult;
78500 }
78501
78502
78503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78504   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78505   unsigned int arg2 ;
78506   float arg3 ;
78507
78508   arg1 = (Dali::Toolkit::TableView *)jarg1;
78509   arg2 = (unsigned int)jarg2;
78510   arg3 = (float)jarg3;
78511   {
78512     try {
78513       (arg1)->SetFixedWidth(arg2,arg3);
78514     } catch (std::out_of_range& e) {
78515       {
78516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78517       };
78518     } catch (std::exception& e) {
78519       {
78520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78521       };
78522     } catch (Dali::DaliException e) {
78523       {
78524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78525       };
78526     } catch (...) {
78527       {
78528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78529       };
78530     }
78531   }
78532
78533 }
78534
78535
78536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78537   float jresult ;
78538   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78539   unsigned int arg2 ;
78540   float result;
78541
78542   arg1 = (Dali::Toolkit::TableView *)jarg1;
78543   arg2 = (unsigned int)jarg2;
78544   {
78545     try {
78546       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78547     } catch (std::out_of_range& e) {
78548       {
78549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78550       };
78551     } catch (std::exception& e) {
78552       {
78553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78554       };
78555     } catch (Dali::DaliException e) {
78556       {
78557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78558       };
78559     } catch (...) {
78560       {
78561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78562       };
78563     }
78564   }
78565
78566   jresult = result;
78567   return jresult;
78568 }
78569
78570
78571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78572   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78573   unsigned int arg2 ;
78574   float arg3 ;
78575
78576   arg1 = (Dali::Toolkit::TableView *)jarg1;
78577   arg2 = (unsigned int)jarg2;
78578   arg3 = (float)jarg3;
78579   {
78580     try {
78581       (arg1)->SetRelativeWidth(arg2,arg3);
78582     } catch (std::out_of_range& e) {
78583       {
78584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78585       };
78586     } catch (std::exception& e) {
78587       {
78588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78589       };
78590     } catch (Dali::DaliException e) {
78591       {
78592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78593       };
78594     } catch (...) {
78595       {
78596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78597       };
78598     }
78599   }
78600
78601 }
78602
78603
78604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78605   float jresult ;
78606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78607   unsigned int arg2 ;
78608   float result;
78609
78610   arg1 = (Dali::Toolkit::TableView *)jarg1;
78611   arg2 = (unsigned int)jarg2;
78612   {
78613     try {
78614       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78615     } catch (std::out_of_range& e) {
78616       {
78617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78618       };
78619     } catch (std::exception& e) {
78620       {
78621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78622       };
78623     } catch (Dali::DaliException e) {
78624       {
78625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78626       };
78627     } catch (...) {
78628       {
78629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78630       };
78631     }
78632   }
78633
78634   jresult = result;
78635   return jresult;
78636 }
78637
78638
78639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78640   unsigned int jresult ;
78641   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78642   unsigned int result;
78643
78644   arg1 = (Dali::Toolkit::TableView *)jarg1;
78645   {
78646     try {
78647       result = (unsigned int)(arg1)->GetRows();
78648     } catch (std::out_of_range& e) {
78649       {
78650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78651       };
78652     } catch (std::exception& e) {
78653       {
78654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78655       };
78656     } catch (Dali::DaliException e) {
78657       {
78658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78659       };
78660     } catch (...) {
78661       {
78662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78663       };
78664     }
78665   }
78666
78667   jresult = result;
78668   return jresult;
78669 }
78670
78671
78672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78673   unsigned int jresult ;
78674   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78675   unsigned int result;
78676
78677   arg1 = (Dali::Toolkit::TableView *)jarg1;
78678   {
78679     try {
78680       result = (unsigned int)(arg1)->GetColumns();
78681     } catch (std::out_of_range& e) {
78682       {
78683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78684       };
78685     } catch (std::exception& e) {
78686       {
78687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78688       };
78689     } catch (Dali::DaliException e) {
78690       {
78691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78692       };
78693     } catch (...) {
78694       {
78695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78696       };
78697     }
78698   }
78699
78700   jresult = result;
78701   return jresult;
78702 }
78703
78704
78705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78706   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78707   Dali::Toolkit::TableView::CellPosition arg2 ;
78708   Dali::HorizontalAlignment::Type arg3 ;
78709   Dali::VerticalAlignment::Type arg4 ;
78710   Dali::Toolkit::TableView::CellPosition *argp2 ;
78711
78712   arg1 = (Dali::Toolkit::TableView *)jarg1;
78713   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78714   if (!argp2) {
78715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78716     return ;
78717   }
78718   arg2 = *argp2;
78719   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78720   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78721   {
78722     try {
78723       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78724     } catch (std::out_of_range& e) {
78725       {
78726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78727       };
78728     } catch (std::exception& e) {
78729       {
78730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78731       };
78732     } catch (Dali::DaliException e) {
78733       {
78734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78735       };
78736     } catch (...) {
78737       {
78738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78739       };
78740     }
78741   }
78742
78743 }
78744
78745
78746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78747   unsigned int jresult ;
78748   unsigned int result;
78749
78750   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78751   jresult = result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78757   int jresult ;
78758   int result;
78759
78760   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78761   jresult = (int)result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78767   int jresult ;
78768   int result;
78769
78770   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78771   jresult = (int)result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78777   int jresult ;
78778   int result;
78779
78780   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78781   jresult = (int)result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78787   int jresult ;
78788   int result;
78789
78790   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78791   jresult = (int)result;
78792   return jresult;
78793 }
78794
78795
78796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78797   int jresult ;
78798   int result;
78799
78800   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78801   jresult = (int)result;
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78807   int jresult ;
78808   int result;
78809
78810   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78811   jresult = (int)result;
78812   return jresult;
78813 }
78814
78815
78816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78817   int jresult ;
78818   int result;
78819
78820   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78821   jresult = (int)result;
78822   return jresult;
78823 }
78824
78825
78826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78827   int jresult ;
78828   int result;
78829
78830   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78831   jresult = (int)result;
78832   return jresult;
78833 }
78834
78835
78836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78837   int jresult ;
78838   int result;
78839
78840   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78841   jresult = (int)result;
78842   return jresult;
78843 }
78844
78845
78846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78847   int jresult ;
78848   int result;
78849
78850   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78851   jresult = (int)result;
78852   return jresult;
78853 }
78854
78855
78856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78857   int jresult ;
78858   int result;
78859
78860   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78861   jresult = (int)result;
78862   return jresult;
78863 }
78864
78865
78866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78867   int jresult ;
78868   int result;
78869
78870   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78871   jresult = (int)result;
78872   return jresult;
78873 }
78874
78875
78876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78877   int jresult ;
78878   int result;
78879
78880   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78881   jresult = (int)result;
78882   return jresult;
78883 }
78884
78885
78886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78887   int jresult ;
78888   int result;
78889
78890   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78891   jresult = (int)result;
78892   return jresult;
78893 }
78894
78895
78896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78897   int jresult ;
78898   int result;
78899
78900   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78901   jresult = (int)result;
78902   return jresult;
78903 }
78904
78905
78906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78907   int jresult ;
78908   int result;
78909
78910   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78911   jresult = (int)result;
78912   return jresult;
78913 }
78914
78915
78916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78917   int jresult ;
78918   int result;
78919
78920   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78921   jresult = (int)result;
78922   return jresult;
78923 }
78924
78925
78926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78927   int jresult ;
78928   int result;
78929
78930   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78931   jresult = (int)result;
78932   return jresult;
78933 }
78934
78935
78936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78937   void * jresult ;
78938   Dali::Toolkit::TextLabel::Property *result = 0 ;
78939
78940   {
78941     try {
78942       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78943     } catch (std::out_of_range& e) {
78944       {
78945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78946       };
78947     } catch (std::exception& e) {
78948       {
78949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78950       };
78951     } catch (Dali::DaliException e) {
78952       {
78953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78954       };
78955     } catch (...) {
78956       {
78957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78958       };
78959     }
78960   }
78961
78962   jresult = (void *)result;
78963   return jresult;
78964 }
78965
78966
78967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78968   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78969
78970   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78971   {
78972     try {
78973       delete arg1;
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78989       };
78990     }
78991   }
78992
78993 }
78994
78995
78996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78997   void * jresult ;
78998   Dali::Toolkit::TextLabel result;
78999
79000   {
79001     try {
79002       result = Dali::Toolkit::TextLabel::New();
79003     } catch (std::out_of_range& e) {
79004       {
79005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (std::exception& e) {
79008       {
79009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79010       };
79011     } catch (Dali::DaliException e) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79014       };
79015     } catch (...) {
79016       {
79017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79018       };
79019     }
79020   }
79021
79022   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79023   return jresult;
79024 }
79025
79026
79027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79028   void * jresult ;
79029   std::string *arg1 = 0 ;
79030   Dali::Toolkit::TextLabel result;
79031
79032   if (!jarg1) {
79033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79034     return 0;
79035   }
79036   std::string arg1_str(jarg1);
79037   arg1 = &arg1_str;
79038   {
79039     try {
79040       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79048       };
79049     } catch (Dali::DaliException e) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79052       };
79053     } catch (...) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79056       };
79057     }
79058   }
79059
79060   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79061
79062   //argout typemap for const std::string&
79063
79064   return jresult;
79065 }
79066
79067
79068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79069   void * jresult ;
79070   Dali::Toolkit::TextLabel *result = 0 ;
79071
79072   {
79073     try {
79074       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79075     } catch (std::out_of_range& e) {
79076       {
79077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (std::exception& e) {
79080       {
79081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (Dali::DaliException e) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79090       };
79091     }
79092   }
79093
79094   jresult = (void *)result;
79095   return jresult;
79096 }
79097
79098
79099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79100   void * jresult ;
79101   Dali::Toolkit::TextLabel *arg1 = 0 ;
79102   Dali::Toolkit::TextLabel *result = 0 ;
79103
79104   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79105   if (!arg1) {
79106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79107     return 0;
79108   }
79109   {
79110     try {
79111       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79112     } catch (std::out_of_range& e) {
79113       {
79114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79115       };
79116     } catch (std::exception& e) {
79117       {
79118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79119       };
79120     } catch (Dali::DaliException e) {
79121       {
79122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79123       };
79124     } catch (...) {
79125       {
79126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79127       };
79128     }
79129   }
79130
79131   jresult = (void *)result;
79132   return jresult;
79133 }
79134
79135
79136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79137   void * jresult ;
79138   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79139   Dali::Toolkit::TextLabel *arg2 = 0 ;
79140   Dali::Toolkit::TextLabel *result = 0 ;
79141
79142   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79143   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79144   if (!arg2) {
79145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79146     return 0;
79147   }
79148   {
79149     try {
79150       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79151     } catch (std::out_of_range& e) {
79152       {
79153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79154       };
79155     } catch (std::exception& e) {
79156       {
79157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79158       };
79159     } catch (Dali::DaliException e) {
79160       {
79161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79162       };
79163     } catch (...) {
79164       {
79165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79166       };
79167     }
79168   }
79169
79170   jresult = (void *)result;
79171   return jresult;
79172 }
79173
79174
79175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79176   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79177
79178   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79179   {
79180     try {
79181       delete arg1;
79182     } catch (std::out_of_range& e) {
79183       {
79184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79185       };
79186     } catch (std::exception& e) {
79187       {
79188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79189       };
79190     } catch (Dali::DaliException e) {
79191       {
79192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79193       };
79194     } catch (...) {
79195       {
79196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79197       };
79198     }
79199   }
79200
79201 }
79202
79203
79204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79205   void * jresult ;
79206   Dali::BaseHandle arg1 ;
79207   Dali::BaseHandle *argp1 ;
79208   Dali::Toolkit::TextLabel result;
79209
79210   argp1 = (Dali::BaseHandle *)jarg1;
79211   if (!argp1) {
79212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79213     return 0;
79214   }
79215   arg1 = *argp1;
79216   {
79217     try {
79218       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79219     } catch (std::out_of_range& e) {
79220       {
79221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79222       };
79223     } catch (std::exception& e) {
79224       {
79225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79226       };
79227     } catch (Dali::DaliException e) {
79228       {
79229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79230       };
79231     } catch (...) {
79232       {
79233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79234       };
79235     }
79236   }
79237
79238   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79239   return jresult;
79240 }
79241
79242
79243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79244   void * jresult ;
79245   Dali::Toolkit::AccessibilityManager *result = 0 ;
79246
79247   {
79248     try {
79249       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79250     } catch (std::out_of_range& e) {
79251       {
79252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79253       };
79254     } catch (std::exception& e) {
79255       {
79256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79257       };
79258     } catch (Dali::DaliException e) {
79259       {
79260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79261       };
79262     } catch (...) {
79263       {
79264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79265       };
79266     }
79267   }
79268
79269   jresult = (void *)result;
79270   return jresult;
79271 }
79272
79273
79274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79276
79277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79278   {
79279     try {
79280       delete arg1;
79281     } catch (std::out_of_range& e) {
79282       {
79283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79284       };
79285     } catch (std::exception& e) {
79286       {
79287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79288       };
79289     } catch (Dali::DaliException e) {
79290       {
79291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79292       };
79293     } catch (...) {
79294       {
79295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79296       };
79297     }
79298   }
79299
79300 }
79301
79302
79303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79304   void * jresult ;
79305   Dali::Toolkit::AccessibilityManager result;
79306
79307   {
79308     try {
79309       result = Dali::Toolkit::AccessibilityManager::Get();
79310     } catch (std::out_of_range& e) {
79311       {
79312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79313       };
79314     } catch (std::exception& e) {
79315       {
79316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79317       };
79318     } catch (Dali::DaliException e) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79321       };
79322     } catch (...) {
79323       {
79324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79325       };
79326     }
79327   }
79328
79329   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79330   return jresult;
79331 }
79332
79333
79334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79336   Dali::Actor arg2 ;
79337   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79338   std::string *arg4 = 0 ;
79339   Dali::Actor *argp2 ;
79340
79341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79342   argp2 = (Dali::Actor *)jarg2;
79343   if (!argp2) {
79344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79345     return ;
79346   }
79347   arg2 = *argp2;
79348   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79349   if (!jarg4) {
79350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79351     return ;
79352   }
79353   std::string arg4_str(jarg4);
79354   arg4 = &arg4_str;
79355   {
79356     try {
79357       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79358     } catch (std::out_of_range& e) {
79359       {
79360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79361       };
79362     } catch (std::exception& e) {
79363       {
79364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79365       };
79366     } catch (Dali::DaliException e) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79369       };
79370     } catch (...) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79373       };
79374     }
79375   }
79376
79377
79378   //argout typemap for const std::string&
79379
79380 }
79381
79382
79383 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79384   char * jresult ;
79385   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79386   Dali::Actor arg2 ;
79387   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79388   Dali::Actor *argp2 ;
79389   std::string result;
79390
79391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79392   argp2 = (Dali::Actor *)jarg2;
79393   if (!argp2) {
79394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79395     return 0;
79396   }
79397   arg2 = *argp2;
79398   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79399   {
79400     try {
79401       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79402     } catch (std::out_of_range& e) {
79403       {
79404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79405       };
79406     } catch (std::exception& e) {
79407       {
79408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79409       };
79410     } catch (Dali::DaliException e) {
79411       {
79412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79413       };
79414     } catch (...) {
79415       {
79416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79417       };
79418     }
79419   }
79420
79421   jresult = SWIG_csharp_string_callback((&result)->c_str());
79422   return jresult;
79423 }
79424
79425
79426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79427   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79428   Dali::Actor arg2 ;
79429   unsigned int arg3 ;
79430   Dali::Actor *argp2 ;
79431
79432   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79433   argp2 = (Dali::Actor *)jarg2;
79434   if (!argp2) {
79435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79436     return ;
79437   }
79438   arg2 = *argp2;
79439   arg3 = (unsigned int)jarg3;
79440   {
79441     try {
79442       (arg1)->SetFocusOrder(arg2,arg3);
79443     } catch (std::out_of_range& e) {
79444       {
79445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79446       };
79447     } catch (std::exception& e) {
79448       {
79449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79450       };
79451     } catch (Dali::DaliException e) {
79452       {
79453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79454       };
79455     } catch (...) {
79456       {
79457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79458       };
79459     }
79460   }
79461
79462 }
79463
79464
79465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79466   unsigned int jresult ;
79467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79468   Dali::Actor arg2 ;
79469   Dali::Actor *argp2 ;
79470   unsigned int result;
79471
79472   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79473   argp2 = (Dali::Actor *)jarg2;
79474   if (!argp2) {
79475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79476     return 0;
79477   }
79478   arg2 = *argp2;
79479   {
79480     try {
79481       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79482     } catch (std::out_of_range& e) {
79483       {
79484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79485       };
79486     } catch (std::exception& e) {
79487       {
79488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79489       };
79490     } catch (Dali::DaliException e) {
79491       {
79492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79493       };
79494     } catch (...) {
79495       {
79496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79497       };
79498     }
79499   }
79500
79501   jresult = result;
79502   return jresult;
79503 }
79504
79505
79506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79507   unsigned int jresult ;
79508   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79509   unsigned int result;
79510
79511   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79512   {
79513     try {
79514       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79515     } catch (std::out_of_range& e) {
79516       {
79517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79518       };
79519     } catch (std::exception& e) {
79520       {
79521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79522       };
79523     } catch (Dali::DaliException e) {
79524       {
79525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79526       };
79527     } catch (...) {
79528       {
79529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79530       };
79531     }
79532   }
79533
79534   jresult = result;
79535   return jresult;
79536 }
79537
79538
79539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79540   void * jresult ;
79541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79542   unsigned int arg2 ;
79543   Dali::Actor result;
79544
79545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79546   arg2 = (unsigned int)jarg2;
79547   {
79548     try {
79549       result = (arg1)->GetActorByFocusOrder(arg2);
79550     } catch (std::out_of_range& e) {
79551       {
79552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79553       };
79554     } catch (std::exception& e) {
79555       {
79556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79557       };
79558     } catch (Dali::DaliException e) {
79559       {
79560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79561       };
79562     } catch (...) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79565       };
79566     }
79567   }
79568
79569   jresult = new Dali::Actor((const Dali::Actor &)result);
79570   return jresult;
79571 }
79572
79573
79574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79575   unsigned int jresult ;
79576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79577   Dali::Actor arg2 ;
79578   Dali::Actor *argp2 ;
79579   bool result;
79580
79581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79582   argp2 = (Dali::Actor *)jarg2;
79583   if (!argp2) {
79584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79585     return 0;
79586   }
79587   arg2 = *argp2;
79588   {
79589     try {
79590       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (Dali::DaliException e) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79602       };
79603     } catch (...) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79606       };
79607     }
79608   }
79609
79610   jresult = result;
79611   return jresult;
79612 }
79613
79614
79615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79616   void * jresult ;
79617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79618   Dali::Actor result;
79619
79620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79621   {
79622     try {
79623       result = (arg1)->GetCurrentFocusActor();
79624     } catch (std::out_of_range& e) {
79625       {
79626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79627       };
79628     } catch (std::exception& e) {
79629       {
79630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79631       };
79632     } catch (Dali::DaliException e) {
79633       {
79634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79635       };
79636     } catch (...) {
79637       {
79638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79639       };
79640     }
79641   }
79642
79643   jresult = new Dali::Actor((const Dali::Actor &)result);
79644   return jresult;
79645 }
79646
79647
79648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79649   void * jresult ;
79650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79651   Dali::Actor result;
79652
79653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79654   {
79655     try {
79656       result = (arg1)->GetCurrentFocusGroup();
79657     } catch (std::out_of_range& e) {
79658       {
79659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79660       };
79661     } catch (std::exception& e) {
79662       {
79663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79664       };
79665     } catch (Dali::DaliException e) {
79666       {
79667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79668       };
79669     } catch (...) {
79670       {
79671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79672       };
79673     }
79674   }
79675
79676   jresult = new Dali::Actor((const Dali::Actor &)result);
79677   return jresult;
79678 }
79679
79680
79681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79682   unsigned int jresult ;
79683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79684   unsigned int result;
79685
79686   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79687   {
79688     try {
79689       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79690     } catch (std::out_of_range& e) {
79691       {
79692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79693       };
79694     } catch (std::exception& e) {
79695       {
79696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (Dali::DaliException e) {
79699       {
79700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79701       };
79702     } catch (...) {
79703       {
79704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79705       };
79706     }
79707   }
79708
79709   jresult = result;
79710   return jresult;
79711 }
79712
79713
79714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79715   unsigned int jresult ;
79716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79717   bool result;
79718
79719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79720   {
79721     try {
79722       result = (bool)(arg1)->MoveFocusForward();
79723     } catch (std::out_of_range& e) {
79724       {
79725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79726       };
79727     } catch (std::exception& e) {
79728       {
79729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79730       };
79731     } catch (Dali::DaliException e) {
79732       {
79733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79734       };
79735     } catch (...) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79738       };
79739     }
79740   }
79741
79742   jresult = result;
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79748   unsigned int jresult ;
79749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79750   bool result;
79751
79752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79753   {
79754     try {
79755       result = (bool)(arg1)->MoveFocusBackward();
79756     } catch (std::out_of_range& e) {
79757       {
79758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79759       };
79760     } catch (std::exception& e) {
79761       {
79762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79763       };
79764     } catch (Dali::DaliException e) {
79765       {
79766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79767       };
79768     } catch (...) {
79769       {
79770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79771       };
79772     }
79773   }
79774
79775   jresult = result;
79776   return jresult;
79777 }
79778
79779
79780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79781   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79782
79783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79784   {
79785     try {
79786       (arg1)->ClearFocus();
79787     } catch (std::out_of_range& e) {
79788       {
79789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79790       };
79791     } catch (std::exception& e) {
79792       {
79793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79794       };
79795     } catch (Dali::DaliException e) {
79796       {
79797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79802       };
79803     }
79804   }
79805
79806 }
79807
79808
79809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79811
79812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79813   {
79814     try {
79815       (arg1)->Reset();
79816     } catch (std::out_of_range& e) {
79817       {
79818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79819       };
79820     } catch (std::exception& e) {
79821       {
79822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79823       };
79824     } catch (Dali::DaliException e) {
79825       {
79826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79827       };
79828     } catch (...) {
79829       {
79830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79831       };
79832     }
79833   }
79834
79835 }
79836
79837
79838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79839   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79840   Dali::Actor arg2 ;
79841   bool arg3 ;
79842   Dali::Actor *argp2 ;
79843
79844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79845   argp2 = (Dali::Actor *)jarg2;
79846   if (!argp2) {
79847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79848     return ;
79849   }
79850   arg2 = *argp2;
79851   arg3 = jarg3 ? true : false;
79852   {
79853     try {
79854       (arg1)->SetFocusGroup(arg2,arg3);
79855     } catch (std::out_of_range& e) {
79856       {
79857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79858       };
79859     } catch (std::exception& e) {
79860       {
79861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79862       };
79863     } catch (Dali::DaliException e) {
79864       {
79865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79866       };
79867     } catch (...) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79870       };
79871     }
79872   }
79873
79874 }
79875
79876
79877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79878   unsigned int jresult ;
79879   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79880   Dali::Actor arg2 ;
79881   Dali::Actor *argp2 ;
79882   bool result;
79883
79884   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79885   argp2 = (Dali::Actor *)jarg2;
79886   if (!argp2) {
79887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79888     return 0;
79889   }
79890   arg2 = *argp2;
79891   {
79892     try {
79893       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79894     } catch (std::out_of_range& e) {
79895       {
79896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79897       };
79898     } catch (std::exception& e) {
79899       {
79900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79901       };
79902     } catch (Dali::DaliException e) {
79903       {
79904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79905       };
79906     } catch (...) {
79907       {
79908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79909       };
79910     }
79911   }
79912
79913   jresult = result;
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79920   bool arg2 ;
79921
79922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79923   arg2 = jarg2 ? true : false;
79924   {
79925     try {
79926       (arg1)->SetGroupMode(arg2);
79927     } catch (std::out_of_range& e) {
79928       {
79929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79930       };
79931     } catch (std::exception& e) {
79932       {
79933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79934       };
79935     } catch (Dali::DaliException e) {
79936       {
79937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79938       };
79939     } catch (...) {
79940       {
79941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79942       };
79943     }
79944   }
79945
79946 }
79947
79948
79949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79950   unsigned int jresult ;
79951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79952   bool result;
79953
79954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79955   {
79956     try {
79957       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79958     } catch (std::out_of_range& e) {
79959       {
79960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79961       };
79962     } catch (std::exception& e) {
79963       {
79964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79965       };
79966     } catch (Dali::DaliException e) {
79967       {
79968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79969       };
79970     } catch (...) {
79971       {
79972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79973       };
79974     }
79975   }
79976
79977   jresult = result;
79978   return jresult;
79979 }
79980
79981
79982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79984   bool arg2 ;
79985
79986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79987   arg2 = jarg2 ? true : false;
79988   {
79989     try {
79990       (arg1)->SetWrapMode(arg2);
79991     } catch (std::out_of_range& e) {
79992       {
79993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79994       };
79995     } catch (std::exception& e) {
79996       {
79997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79998       };
79999     } catch (Dali::DaliException e) {
80000       {
80001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80002       };
80003     } catch (...) {
80004       {
80005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80006       };
80007     }
80008   }
80009
80010 }
80011
80012
80013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80014   unsigned int jresult ;
80015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80016   bool result;
80017
80018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80019   {
80020     try {
80021       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80022     } catch (std::out_of_range& e) {
80023       {
80024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80025       };
80026     } catch (std::exception& e) {
80027       {
80028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80029       };
80030     } catch (Dali::DaliException e) {
80031       {
80032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80033       };
80034     } catch (...) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80037       };
80038     }
80039   }
80040
80041   jresult = result;
80042   return jresult;
80043 }
80044
80045
80046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80048   Dali::Actor arg2 ;
80049   Dali::Actor *argp2 ;
80050
80051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80052   argp2 = (Dali::Actor *)jarg2;
80053   if (!argp2) {
80054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80055     return ;
80056   }
80057   arg2 = *argp2;
80058   {
80059     try {
80060       (arg1)->SetFocusIndicatorActor(arg2);
80061     } catch (std::out_of_range& e) {
80062       {
80063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80064       };
80065     } catch (std::exception& e) {
80066       {
80067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80068       };
80069     } catch (Dali::DaliException e) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80072       };
80073     } catch (...) {
80074       {
80075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80076       };
80077     }
80078   }
80079
80080 }
80081
80082
80083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80084   void * jresult ;
80085   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80086   Dali::Actor result;
80087
80088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80089   {
80090     try {
80091       result = (arg1)->GetFocusIndicatorActor();
80092     } catch (std::out_of_range& e) {
80093       {
80094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80095       };
80096     } catch (std::exception& e) {
80097       {
80098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80099       };
80100     } catch (Dali::DaliException e) {
80101       {
80102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80103       };
80104     } catch (...) {
80105       {
80106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80107       };
80108     }
80109   }
80110
80111   jresult = new Dali::Actor((const Dali::Actor &)result);
80112   return jresult;
80113 }
80114
80115
80116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80117   void * jresult ;
80118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80119   Dali::Actor arg2 ;
80120   Dali::Actor *argp2 ;
80121   Dali::Actor result;
80122
80123   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80124   argp2 = (Dali::Actor *)jarg2;
80125   if (!argp2) {
80126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80127     return 0;
80128   }
80129   arg2 = *argp2;
80130   {
80131     try {
80132       result = (arg1)->GetFocusGroup(arg2);
80133     } catch (std::out_of_range& e) {
80134       {
80135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80136       };
80137     } catch (std::exception& e) {
80138       {
80139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (Dali::DaliException e) {
80142       {
80143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80144       };
80145     } catch (...) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80148       };
80149     }
80150   }
80151
80152   jresult = new Dali::Actor((const Dali::Actor &)result);
80153   return jresult;
80154 }
80155
80156
80157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80158   void * jresult ;
80159   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80160   Dali::Vector2 result;
80161
80162   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80163   {
80164     try {
80165       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80166     } catch (std::out_of_range& e) {
80167       {
80168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80169       };
80170     } catch (std::exception& e) {
80171       {
80172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (Dali::DaliException e) {
80175       {
80176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80177       };
80178     } catch (...) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80181       };
80182     }
80183   }
80184
80185   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80186   return jresult;
80187 }
80188
80189
80190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80191   void * jresult ;
80192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80193   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80194
80195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80196   {
80197     try {
80198       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80199     } catch (std::out_of_range& e) {
80200       {
80201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80202       };
80203     } catch (std::exception& e) {
80204       {
80205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80206       };
80207     } catch (Dali::DaliException e) {
80208       {
80209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80210       };
80211     } catch (...) {
80212       {
80213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80214       };
80215     }
80216   }
80217
80218   jresult = (void *)result;
80219   return jresult;
80220 }
80221
80222
80223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80224   void * jresult ;
80225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80226   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80227
80228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80229   {
80230     try {
80231       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80232     } catch (std::out_of_range& e) {
80233       {
80234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80235       };
80236     } catch (std::exception& e) {
80237       {
80238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80239       };
80240     } catch (Dali::DaliException e) {
80241       {
80242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80243       };
80244     } catch (...) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80247       };
80248     }
80249   }
80250
80251   jresult = (void *)result;
80252   return jresult;
80253 }
80254
80255
80256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80257   void * jresult ;
80258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80259   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80260
80261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80262   {
80263     try {
80264       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
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 (Dali::DaliException e) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80276       };
80277     } catch (...) {
80278       {
80279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80280       };
80281     }
80282   }
80283
80284   jresult = (void *)result;
80285   return jresult;
80286 }
80287
80288
80289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80290   void * jresult ;
80291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80292   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80293
80294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80295   {
80296     try {
80297       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80298     } catch (std::out_of_range& e) {
80299       {
80300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80301       };
80302     } catch (std::exception& e) {
80303       {
80304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80305       };
80306     } catch (Dali::DaliException e) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80309       };
80310     } catch (...) {
80311       {
80312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80313       };
80314     }
80315   }
80316
80317   jresult = (void *)result;
80318   return jresult;
80319 }
80320
80321
80322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80323   void * jresult ;
80324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80325   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80326
80327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80328   {
80329     try {
80330       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80331     } catch (std::out_of_range& e) {
80332       {
80333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80334       };
80335     } catch (std::exception& e) {
80336       {
80337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80338       };
80339     } catch (Dali::DaliException e) {
80340       {
80341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80342       };
80343     } catch (...) {
80344       {
80345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80346       };
80347     }
80348   }
80349
80350   jresult = (void *)result;
80351   return jresult;
80352 }
80353
80354
80355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80356   void * jresult ;
80357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80358   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80359
80360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80361   {
80362     try {
80363       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80364     } catch (std::out_of_range& e) {
80365       {
80366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80367       };
80368     } catch (std::exception& e) {
80369       {
80370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80371       };
80372     } catch (Dali::DaliException e) {
80373       {
80374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80375       };
80376     } catch (...) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80379       };
80380     }
80381   }
80382
80383   jresult = (void *)result;
80384   return jresult;
80385 }
80386
80387
80388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80389   void * jresult ;
80390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80391   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80392
80393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80394   {
80395     try {
80396       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80397     } catch (std::out_of_range& e) {
80398       {
80399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80400       };
80401     } catch (std::exception& e) {
80402       {
80403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80404       };
80405     } catch (Dali::DaliException e) {
80406       {
80407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80408       };
80409     } catch (...) {
80410       {
80411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80412       };
80413     }
80414   }
80415
80416   jresult = (void *)result;
80417   return jresult;
80418 }
80419
80420
80421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80422   void * jresult ;
80423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80424   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80425
80426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80427   {
80428     try {
80429       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80430     } catch (std::out_of_range& e) {
80431       {
80432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80433       };
80434     } catch (std::exception& e) {
80435       {
80436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80437       };
80438     } catch (Dali::DaliException e) {
80439       {
80440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80441       };
80442     } catch (...) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80445       };
80446     }
80447   }
80448
80449   jresult = (void *)result;
80450   return jresult;
80451 }
80452
80453
80454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80455   void * jresult ;
80456   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80457   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80458
80459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80460   {
80461     try {
80462       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80463     } catch (std::out_of_range& e) {
80464       {
80465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80466       };
80467     } catch (std::exception& e) {
80468       {
80469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (Dali::DaliException e) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80474       };
80475     } catch (...) {
80476       {
80477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80478       };
80479     }
80480   }
80481
80482   jresult = (void *)result;
80483   return jresult;
80484 }
80485
80486
80487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80488   void * jresult ;
80489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80490   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80491
80492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80493   {
80494     try {
80495       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80496     } catch (std::out_of_range& e) {
80497       {
80498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80499       };
80500     } catch (std::exception& e) {
80501       {
80502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80503       };
80504     } catch (Dali::DaliException e) {
80505       {
80506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80507       };
80508     } catch (...) {
80509       {
80510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80511       };
80512     }
80513   }
80514
80515   jresult = (void *)result;
80516   return jresult;
80517 }
80518
80519
80520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80521   void * jresult ;
80522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80523   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80524
80525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80526   {
80527     try {
80528       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80529     } catch (std::out_of_range& e) {
80530       {
80531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80532       };
80533     } catch (std::exception& e) {
80534       {
80535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80536       };
80537     } catch (Dali::DaliException e) {
80538       {
80539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80540       };
80541     } catch (...) {
80542       {
80543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80544       };
80545     }
80546   }
80547
80548   jresult = (void *)result;
80549   return jresult;
80550 }
80551
80552
80553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80554   void * jresult ;
80555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80556   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80557
80558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80559   {
80560     try {
80561       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80562     } catch (std::out_of_range& e) {
80563       {
80564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80565       };
80566     } catch (std::exception& e) {
80567       {
80568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80569       };
80570     } catch (Dali::DaliException e) {
80571       {
80572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80573       };
80574     } catch (...) {
80575       {
80576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80577       };
80578     }
80579   }
80580
80581   jresult = (void *)result;
80582   return jresult;
80583 }
80584
80585
80586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80587   void * jresult ;
80588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80589   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80590
80591   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80592   {
80593     try {
80594       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80595     } catch (std::out_of_range& e) {
80596       {
80597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80598       };
80599     } catch (std::exception& e) {
80600       {
80601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80602       };
80603     } catch (Dali::DaliException e) {
80604       {
80605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80606       };
80607     } catch (...) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80610       };
80611     }
80612   }
80613
80614   jresult = (void *)result;
80615   return jresult;
80616 }
80617
80618
80619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80620   void * jresult ;
80621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80622   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80623
80624   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80625   {
80626     try {
80627       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80628     } catch (std::out_of_range& e) {
80629       {
80630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80631       };
80632     } catch (std::exception& e) {
80633       {
80634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80635       };
80636     } catch (Dali::DaliException e) {
80637       {
80638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80643       };
80644     }
80645   }
80646
80647   jresult = (void *)result;
80648   return jresult;
80649 }
80650
80651
80652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80653   void * jresult ;
80654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80655   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80656
80657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80658   {
80659     try {
80660       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80661     } catch (std::out_of_range& e) {
80662       {
80663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (std::exception& e) {
80666       {
80667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (Dali::DaliException e) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80676       };
80677     }
80678   }
80679
80680   jresult = (void *)result;
80681   return jresult;
80682 }
80683
80684
80685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80686   void * jresult ;
80687   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80688   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80689
80690   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80691   {
80692     try {
80693       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80694     } catch (std::out_of_range& e) {
80695       {
80696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80697       };
80698     } catch (std::exception& e) {
80699       {
80700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80701       };
80702     } catch (Dali::DaliException e) {
80703       {
80704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80705       };
80706     } catch (...) {
80707       {
80708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80709       };
80710     }
80711   }
80712
80713   jresult = (void *)result;
80714   return jresult;
80715 }
80716
80717
80718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80719   void * jresult ;
80720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80721   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80722
80723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80724   {
80725     try {
80726       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80727     } catch (std::out_of_range& e) {
80728       {
80729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80730       };
80731     } catch (std::exception& e) {
80732       {
80733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80734       };
80735     } catch (Dali::DaliException e) {
80736       {
80737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80738       };
80739     } catch (...) {
80740       {
80741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80742       };
80743     }
80744   }
80745
80746   jresult = (void *)result;
80747   return jresult;
80748 }
80749
80750
80751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80752   void * jresult ;
80753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80754   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80755
80756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80757   {
80758     try {
80759       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80775       };
80776     }
80777   }
80778
80779   jresult = (void *)result;
80780   return jresult;
80781 }
80782
80783
80784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80785   void * jresult ;
80786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80787   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80788
80789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80790   {
80791     try {
80792       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80793     } catch (std::out_of_range& e) {
80794       {
80795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80796       };
80797     } catch (std::exception& e) {
80798       {
80799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (Dali::DaliException e) {
80802       {
80803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80804       };
80805     } catch (...) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80808       };
80809     }
80810   }
80811
80812   jresult = (void *)result;
80813   return jresult;
80814 }
80815
80816
80817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80818   void * jresult ;
80819   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80820   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80821
80822   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80823   {
80824     try {
80825       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80826     } catch (std::out_of_range& e) {
80827       {
80828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80829       };
80830     } catch (std::exception& e) {
80831       {
80832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80833       };
80834     } catch (Dali::DaliException e) {
80835       {
80836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80837       };
80838     } catch (...) {
80839       {
80840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80841       };
80842     }
80843   }
80844
80845   jresult = (void *)result;
80846   return jresult;
80847 }
80848
80849
80850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80851   void * jresult ;
80852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80853   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80854
80855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80856   {
80857     try {
80858       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80859     } catch (std::out_of_range& e) {
80860       {
80861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80862       };
80863     } catch (std::exception& e) {
80864       {
80865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80866       };
80867     } catch (Dali::DaliException e) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80870       };
80871     } catch (...) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80874       };
80875     }
80876   }
80877
80878   jresult = (void *)result;
80879   return jresult;
80880 }
80881
80882
80883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80884   void * jresult ;
80885   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80886   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80887
80888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80889   {
80890     try {
80891       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80892     } catch (std::out_of_range& e) {
80893       {
80894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80895       };
80896     } catch (std::exception& e) {
80897       {
80898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80899       };
80900     } catch (Dali::DaliException e) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80903       };
80904     } catch (...) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80907       };
80908     }
80909   }
80910
80911   jresult = (void *)result;
80912   return jresult;
80913 }
80914
80915
80916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80917   void * jresult ;
80918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80919   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80920
80921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80922   {
80923     try {
80924       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80925     } catch (std::out_of_range& e) {
80926       {
80927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80928       };
80929     } catch (std::exception& e) {
80930       {
80931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80932       };
80933     } catch (Dali::DaliException e) {
80934       {
80935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80936       };
80937     } catch (...) {
80938       {
80939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80940       };
80941     }
80942   }
80943
80944   jresult = (void *)result;
80945   return jresult;
80946 }
80947
80948
80949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80950   void * jresult ;
80951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80952   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80953
80954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80955   {
80956     try {
80957       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80958     } catch (std::out_of_range& e) {
80959       {
80960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80961       };
80962     } catch (std::exception& e) {
80963       {
80964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80965       };
80966     } catch (Dali::DaliException e) {
80967       {
80968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80969       };
80970     } catch (...) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80973       };
80974     }
80975   }
80976
80977   jresult = (void *)result;
80978   return jresult;
80979 }
80980
80981
80982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80983   void * jresult ;
80984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80985   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80986
80987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80988   {
80989     try {
80990       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80991     } catch (std::out_of_range& e) {
80992       {
80993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80994       };
80995     } catch (std::exception& e) {
80996       {
80997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80998       };
80999     } catch (Dali::DaliException e) {
81000       {
81001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81002       };
81003     } catch (...) {
81004       {
81005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81006       };
81007     }
81008   }
81009
81010   jresult = (void *)result;
81011   return jresult;
81012 }
81013
81014
81015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81016   void * jresult ;
81017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81019
81020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81021   {
81022     try {
81023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81024     } catch (std::out_of_range& e) {
81025       {
81026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81027       };
81028     } catch (std::exception& e) {
81029       {
81030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81031       };
81032     } catch (Dali::DaliException e) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81035       };
81036     } catch (...) {
81037       {
81038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81039       };
81040     }
81041   }
81042
81043   jresult = (void *)result;
81044   return jresult;
81045 }
81046
81047
81048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81049   void * jresult ;
81050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81051   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81052
81053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81054   {
81055     try {
81056       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (Dali::DaliException e) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81072       };
81073     }
81074   }
81075
81076   jresult = (void *)result;
81077   return jresult;
81078 }
81079
81080
81081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81082   void * jresult ;
81083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81084   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81085
81086   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81087   {
81088     try {
81089       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81090     } catch (std::out_of_range& e) {
81091       {
81092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81093       };
81094     } catch (std::exception& e) {
81095       {
81096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81097       };
81098     } catch (Dali::DaliException e) {
81099       {
81100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81101       };
81102     } catch (...) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81105       };
81106     }
81107   }
81108
81109   jresult = (void *)result;
81110   return jresult;
81111 }
81112
81113
81114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81115   void * jresult ;
81116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81117   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81118
81119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81120   {
81121     try {
81122       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81123     } catch (std::out_of_range& e) {
81124       {
81125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81126       };
81127     } catch (std::exception& e) {
81128       {
81129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81130       };
81131     } catch (Dali::DaliException e) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81134       };
81135     } catch (...) {
81136       {
81137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81138       };
81139     }
81140   }
81141
81142   jresult = (void *)result;
81143   return jresult;
81144 }
81145
81146
81147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81148   void * jresult ;
81149   Dali::Toolkit::StyleManager *result = 0 ;
81150
81151   {
81152     try {
81153       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81154     } catch (std::out_of_range& e) {
81155       {
81156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81157       };
81158     } catch (std::exception& e) {
81159       {
81160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81161       };
81162     } catch (Dali::DaliException e) {
81163       {
81164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81165       };
81166     } catch (...) {
81167       {
81168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81169       };
81170     }
81171   }
81172
81173   jresult = (void *)result;
81174   return jresult;
81175 }
81176
81177
81178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81179   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81180
81181   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81182   {
81183     try {
81184       delete arg1;
81185     } catch (std::out_of_range& e) {
81186       {
81187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81188       };
81189     } catch (std::exception& e) {
81190       {
81191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81192       };
81193     } catch (Dali::DaliException e) {
81194       {
81195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81196       };
81197     } catch (...) {
81198       {
81199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81200       };
81201     }
81202   }
81203
81204 }
81205
81206
81207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81208   void * jresult ;
81209   Dali::Toolkit::StyleManager result;
81210
81211   {
81212     try {
81213       result = Dali::Toolkit::StyleManager::Get();
81214     } catch (std::out_of_range& e) {
81215       {
81216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81217       };
81218     } catch (std::exception& e) {
81219       {
81220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81221       };
81222     } catch (Dali::DaliException e) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81225       };
81226     } catch (...) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81229       };
81230     }
81231   }
81232
81233   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81234   return jresult;
81235 }
81236
81237
81238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81239   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81240   std::string *arg2 = 0 ;
81241
81242   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81243   if (!jarg2) {
81244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81245     return ;
81246   }
81247   std::string arg2_str(jarg2);
81248   arg2 = &arg2_str;
81249   {
81250     try {
81251       (arg1)->ApplyTheme((std::string const &)*arg2);
81252     } catch (std::out_of_range& e) {
81253       {
81254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81255       };
81256     } catch (std::exception& e) {
81257       {
81258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81259       };
81260     } catch (Dali::DaliException e) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81263       };
81264     } catch (...) {
81265       {
81266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81267       };
81268     }
81269   }
81270
81271
81272   //argout typemap for const std::string&
81273
81274 }
81275
81276
81277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81278   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81279
81280   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81281   {
81282     try {
81283       (arg1)->ApplyDefaultTheme();
81284     } catch (std::out_of_range& e) {
81285       {
81286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81287       };
81288     } catch (std::exception& e) {
81289       {
81290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81291       };
81292     } catch (Dali::DaliException e) {
81293       {
81294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81295       };
81296     } catch (...) {
81297       {
81298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81299       };
81300     }
81301   }
81302
81303 }
81304
81305
81306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81307   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81308   std::string *arg2 = 0 ;
81309   Dali::Property::Value *arg3 = 0 ;
81310
81311   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81312   if (!jarg2) {
81313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81314     return ;
81315   }
81316   std::string arg2_str(jarg2);
81317   arg2 = &arg2_str;
81318   arg3 = (Dali::Property::Value *)jarg3;
81319   if (!arg3) {
81320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81321     return ;
81322   }
81323   {
81324     try {
81325       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81326     } catch (std::out_of_range& e) {
81327       {
81328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81329       };
81330     } catch (std::exception& e) {
81331       {
81332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81333       };
81334     } catch (Dali::DaliException e) {
81335       {
81336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81337       };
81338     } catch (...) {
81339       {
81340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81341       };
81342     }
81343   }
81344
81345
81346   //argout typemap for const std::string&
81347
81348 }
81349
81350
81351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81352   unsigned int jresult ;
81353   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81354   std::string *arg2 = 0 ;
81355   Dali::Property::Value *arg3 = 0 ;
81356   bool result;
81357
81358   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81359   if (!jarg2) {
81360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81361     return 0;
81362   }
81363   std::string arg2_str(jarg2);
81364   arg2 = &arg2_str;
81365   arg3 = (Dali::Property::Value *)jarg3;
81366   if (!arg3) {
81367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81368     return 0;
81369   }
81370   {
81371     try {
81372       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (Dali::DaliException e) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391
81392   jresult = result;
81393
81394   //argout typemap for const std::string&
81395
81396   return jresult;
81397 }
81398
81399
81400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81401   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81402   Dali::Toolkit::Control arg2 ;
81403   std::string *arg3 = 0 ;
81404   std::string *arg4 = 0 ;
81405   Dali::Toolkit::Control *argp2 ;
81406
81407   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81408   argp2 = (Dali::Toolkit::Control *)jarg2;
81409   if (!argp2) {
81410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81411     return ;
81412   }
81413   arg2 = *argp2;
81414   if (!jarg3) {
81415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81416     return ;
81417   }
81418   std::string arg3_str(jarg3);
81419   arg3 = &arg3_str;
81420   if (!jarg4) {
81421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81422     return ;
81423   }
81424   std::string arg4_str(jarg4);
81425   arg4 = &arg4_str;
81426   {
81427     try {
81428       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81429     } catch (std::out_of_range& e) {
81430       {
81431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81432       };
81433     } catch (std::exception& e) {
81434       {
81435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81436       };
81437     } catch (Dali::DaliException e) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81440       };
81441     } catch (...) {
81442       {
81443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81444       };
81445     }
81446   }
81447
81448
81449   //argout typemap for const std::string&
81450
81451
81452   //argout typemap for const std::string&
81453
81454 }
81455
81456
81457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81458   void * jresult ;
81459   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81460   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81461
81462   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81463   {
81464     try {
81465       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81466     } catch (std::out_of_range& e) {
81467       {
81468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81469       };
81470     } catch (std::exception& e) {
81471       {
81472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81473       };
81474     } catch (Dali::DaliException e) {
81475       {
81476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81477       };
81478     } catch (...) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81481       };
81482     }
81483   }
81484
81485   jresult = (void *)result;
81486   return jresult;
81487 }
81488
81489
81490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81491   int jresult ;
81492   int result;
81493
81494   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81495   jresult = (int)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81501   int jresult ;
81502   int result;
81503
81504   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81505   jresult = (int)result;
81506   return jresult;
81507 }
81508
81509
81510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81511   int jresult ;
81512   int result;
81513
81514   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81515   jresult = (int)result;
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81521   int jresult ;
81522   int result;
81523
81524   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81525   jresult = (int)result;
81526   return jresult;
81527 }
81528
81529
81530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81531   int jresult ;
81532   int result;
81533
81534   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81535   jresult = (int)result;
81536   return jresult;
81537 }
81538
81539
81540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81541   int jresult ;
81542   int result;
81543
81544   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81545   jresult = (int)result;
81546   return jresult;
81547 }
81548
81549
81550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81551   int jresult ;
81552   int result;
81553
81554   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81555   jresult = (int)result;
81556   return jresult;
81557 }
81558
81559
81560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81561   int jresult ;
81562   int result;
81563
81564   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81565   jresult = (int)result;
81566   return jresult;
81567 }
81568
81569
81570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81571   int jresult ;
81572   int result;
81573
81574   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81575   jresult = (int)result;
81576   return jresult;
81577 }
81578
81579
81580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81581   int jresult ;
81582   int result;
81583
81584   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81585   jresult = (int)result;
81586   return jresult;
81587 }
81588
81589
81590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81591   int jresult ;
81592   int result;
81593
81594   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81595   jresult = (int)result;
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81601   int jresult ;
81602   int result;
81603
81604   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81605   jresult = (int)result;
81606   return jresult;
81607 }
81608
81609
81610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81611   int jresult ;
81612   int result;
81613
81614   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81615   jresult = (int)result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81621   int jresult ;
81622   int result;
81623
81624   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81625   jresult = (int)result;
81626   return jresult;
81627 }
81628
81629
81630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81631   int jresult ;
81632   int result;
81633
81634   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81635   jresult = (int)result;
81636   return jresult;
81637 }
81638
81639
81640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81641   void * jresult ;
81642   Dali::Toolkit::Slider::Property *result = 0 ;
81643
81644   {
81645     try {
81646       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81647     } catch (std::out_of_range& e) {
81648       {
81649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81650       };
81651     } catch (std::exception& e) {
81652       {
81653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81654       };
81655     } catch (Dali::DaliException e) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81658       };
81659     } catch (...) {
81660       {
81661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81662       };
81663     }
81664   }
81665
81666   jresult = (void *)result;
81667   return jresult;
81668 }
81669
81670
81671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81672   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81673
81674   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81675   {
81676     try {
81677       delete arg1;
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (Dali::DaliException e) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81693       };
81694     }
81695   }
81696
81697 }
81698
81699
81700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81701   void * jresult ;
81702   Dali::Toolkit::Slider result;
81703
81704   {
81705     try {
81706       result = Dali::Toolkit::Slider::New();
81707     } catch (std::out_of_range& e) {
81708       {
81709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81710       };
81711     } catch (std::exception& e) {
81712       {
81713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81714       };
81715     } catch (Dali::DaliException e) {
81716       {
81717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81718       };
81719     } catch (...) {
81720       {
81721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81722       };
81723     }
81724   }
81725
81726   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81727   return jresult;
81728 }
81729
81730
81731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81732   void * jresult ;
81733   Dali::Toolkit::Slider *result = 0 ;
81734
81735   {
81736     try {
81737       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81738     } catch (std::out_of_range& e) {
81739       {
81740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81741       };
81742     } catch (std::exception& e) {
81743       {
81744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81745       };
81746     } catch (Dali::DaliException e) {
81747       {
81748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81749       };
81750     } catch (...) {
81751       {
81752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81753       };
81754     }
81755   }
81756
81757   jresult = (void *)result;
81758   return jresult;
81759 }
81760
81761
81762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81763   void * jresult ;
81764   Dali::Toolkit::Slider *arg1 = 0 ;
81765   Dali::Toolkit::Slider *result = 0 ;
81766
81767   arg1 = (Dali::Toolkit::Slider *)jarg1;
81768   if (!arg1) {
81769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81770     return 0;
81771   }
81772   {
81773     try {
81774       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81775     } catch (std::out_of_range& e) {
81776       {
81777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81778       };
81779     } catch (std::exception& e) {
81780       {
81781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81782       };
81783     } catch (Dali::DaliException e) {
81784       {
81785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81786       };
81787     } catch (...) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81790       };
81791     }
81792   }
81793
81794   jresult = (void *)result;
81795   return jresult;
81796 }
81797
81798
81799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81800   void * jresult ;
81801   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81802   Dali::Toolkit::Slider *arg2 = 0 ;
81803   Dali::Toolkit::Slider *result = 0 ;
81804
81805   arg1 = (Dali::Toolkit::Slider *)jarg1;
81806   arg2 = (Dali::Toolkit::Slider *)jarg2;
81807   if (!arg2) {
81808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81809     return 0;
81810   }
81811   {
81812     try {
81813       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81814     } catch (std::out_of_range& e) {
81815       {
81816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81817       };
81818     } catch (std::exception& e) {
81819       {
81820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81821       };
81822     } catch (Dali::DaliException e) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81825       };
81826     } catch (...) {
81827       {
81828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81829       };
81830     }
81831   }
81832
81833   jresult = (void *)result;
81834   return jresult;
81835 }
81836
81837
81838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81839   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81840
81841   arg1 = (Dali::Toolkit::Slider *)jarg1;
81842   {
81843     try {
81844       delete arg1;
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (Dali::DaliException e) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81856       };
81857     } catch (...) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81860       };
81861     }
81862   }
81863
81864 }
81865
81866
81867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81868   void * jresult ;
81869   Dali::BaseHandle arg1 ;
81870   Dali::BaseHandle *argp1 ;
81871   Dali::Toolkit::Slider result;
81872
81873   argp1 = (Dali::BaseHandle *)jarg1;
81874   if (!argp1) {
81875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81876     return 0;
81877   }
81878   arg1 = *argp1;
81879   {
81880     try {
81881       result = Dali::Toolkit::Slider::DownCast(arg1);
81882     } catch (std::out_of_range& e) {
81883       {
81884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81885       };
81886     } catch (std::exception& e) {
81887       {
81888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81889       };
81890     } catch (Dali::DaliException e) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81893       };
81894     } catch (...) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81897       };
81898     }
81899   }
81900
81901   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81902   return jresult;
81903 }
81904
81905
81906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81907   void * jresult ;
81908   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81909   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81910
81911   arg1 = (Dali::Toolkit::Slider *)jarg1;
81912   {
81913     try {
81914       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81915     } catch (std::out_of_range& e) {
81916       {
81917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81918       };
81919     } catch (std::exception& e) {
81920       {
81921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81922       };
81923     } catch (Dali::DaliException e) {
81924       {
81925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81930       };
81931     }
81932   }
81933
81934   jresult = (void *)result;
81935   return jresult;
81936 }
81937
81938
81939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81940   void * jresult ;
81941   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81942   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81943
81944   arg1 = (Dali::Toolkit::Slider *)jarg1;
81945   {
81946     try {
81947       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81948     } catch (std::out_of_range& e) {
81949       {
81950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81951       };
81952     } catch (std::exception& e) {
81953       {
81954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81955       };
81956     } catch (Dali::DaliException e) {
81957       {
81958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81959       };
81960     } catch (...) {
81961       {
81962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81963       };
81964     }
81965   }
81966
81967   jresult = (void *)result;
81968   return jresult;
81969 }
81970
81971
81972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81973   void * jresult ;
81974   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81975   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81976
81977   arg1 = (Dali::Toolkit::Slider *)jarg1;
81978   {
81979     try {
81980       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (Dali::DaliException e) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81992       };
81993     } catch (...) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81996       };
81997     }
81998   }
81999
82000   jresult = (void *)result;
82001   return jresult;
82002 }
82003
82004
82005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82006   int jresult ;
82007   int result;
82008
82009   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82010   jresult = (int)result;
82011   return jresult;
82012 }
82013
82014
82015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82016   int jresult ;
82017   int result;
82018
82019   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82020   jresult = (int)result;
82021   return jresult;
82022 }
82023
82024
82025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82026   int jresult ;
82027   int result;
82028
82029   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82030   jresult = (int)result;
82031   return jresult;
82032 }
82033
82034
82035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82036   int jresult ;
82037   int result;
82038
82039   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82040   jresult = (int)result;
82041   return jresult;
82042 }
82043
82044
82045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
82046   int result;
82047
82048   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
82049
82050   return result;
82051 }
82052
82053
82054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82055   void * jresult ;
82056   Dali::Toolkit::VideoView::Property *result = 0 ;
82057
82058   {
82059     try {
82060       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82061     } catch (std::out_of_range& e) {
82062       {
82063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (std::exception& e) {
82066       {
82067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (Dali::DaliException e) {
82070       {
82071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82072       };
82073     } catch (...) {
82074       {
82075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82076       };
82077     }
82078   }
82079
82080   jresult = (void *)result;
82081   return jresult;
82082 }
82083
82084
82085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82086   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82087
82088   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82089   {
82090     try {
82091       delete arg1;
82092     } catch (std::out_of_range& e) {
82093       {
82094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82095       };
82096     } catch (std::exception& e) {
82097       {
82098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82099       };
82100     } catch (Dali::DaliException e) {
82101       {
82102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82103       };
82104     } catch (...) {
82105       {
82106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82107       };
82108     }
82109   }
82110
82111 }
82112
82113
82114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82115   void * jresult ;
82116   Dali::Toolkit::VideoView result;
82117
82118   {
82119     try {
82120       result = Dali::Toolkit::VideoView::New();
82121     } catch (std::out_of_range& e) {
82122       {
82123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82124       };
82125     } catch (std::exception& e) {
82126       {
82127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82128       };
82129     } catch (Dali::DaliException e) {
82130       {
82131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82132       };
82133     } catch (...) {
82134       {
82135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82136       };
82137     }
82138   }
82139
82140   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82141   return jresult;
82142 }
82143
82144
82145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82146   void * jresult ;
82147   std::string *arg1 = 0 ;
82148   Dali::Toolkit::VideoView result;
82149
82150   if (!jarg1) {
82151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82152     return 0;
82153   }
82154   std::string arg1_str(jarg1);
82155   arg1 = &arg1_str;
82156   {
82157     try {
82158       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82159     } catch (std::out_of_range& e) {
82160       {
82161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82162       };
82163     } catch (std::exception& e) {
82164       {
82165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82166       };
82167     } catch (Dali::DaliException e) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82174       };
82175     }
82176   }
82177
82178   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82179
82180   //argout typemap for const std::string&
82181
82182   return jresult;
82183 }
82184
82185
82186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82187   void * jresult ;
82188   Dali::Toolkit::VideoView result;
82189   {
82190     try {
82191       result = Dali::Toolkit::VideoView::New(swCodec);
82192     } catch (std::out_of_range& e) {
82193       {
82194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82195       };
82196     } catch (std::exception& e) {
82197       {
82198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82199       };
82200     } catch (Dali::DaliException e) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82207       };
82208     }
82209   }
82210
82211   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82212
82213   //argout typemap for const std::string&
82214
82215   return jresult;
82216 }
82217
82218
82219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82220   void * jresult ;
82221   std::string *arg1 = 0 ;
82222   Dali::Toolkit::VideoView result;
82223
82224   if (!jarg1) {
82225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82226     return 0;
82227   }
82228   std::string arg1_str(jarg1);
82229   arg1 = &arg1_str;
82230   {
82231     try {
82232       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
82233     } catch (std::out_of_range& e) {
82234       {
82235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82236       };
82237     } catch (std::exception& e) {
82238       {
82239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82240       };
82241     } catch (Dali::DaliException e) {
82242       {
82243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82244       };
82245     } catch (...) {
82246       {
82247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82248       };
82249     }
82250   }
82251
82252   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82253
82254   //argout typemap for const std::string&
82255
82256   return jresult;
82257 }
82258
82259
82260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82261   void * jresult ;
82262   Dali::Toolkit::VideoView *result = 0 ;
82263
82264   {
82265     try {
82266       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82267     } catch (std::out_of_range& e) {
82268       {
82269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82270       };
82271     } catch (std::exception& e) {
82272       {
82273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82274       };
82275     } catch (Dali::DaliException e) {
82276       {
82277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82278       };
82279     } catch (...) {
82280       {
82281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82282       };
82283     }
82284   }
82285
82286   jresult = (void *)result;
82287   return jresult;
82288 }
82289
82290
82291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82292   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82293
82294   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82295   {
82296     try {
82297       delete arg1;
82298     } catch (std::out_of_range& e) {
82299       {
82300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82301       };
82302     } catch (std::exception& e) {
82303       {
82304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82305       };
82306     } catch (Dali::DaliException e) {
82307       {
82308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82309       };
82310     } catch (...) {
82311       {
82312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82313       };
82314     }
82315   }
82316
82317 }
82318
82319
82320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82321   void * jresult ;
82322   Dali::Toolkit::VideoView *arg1 = 0 ;
82323   Dali::Toolkit::VideoView *result = 0 ;
82324
82325   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82326   if (!arg1) {
82327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82328     return 0;
82329   }
82330   {
82331     try {
82332       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82333     } catch (std::out_of_range& e) {
82334       {
82335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82336       };
82337     } catch (std::exception& e) {
82338       {
82339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (Dali::DaliException e) {
82342       {
82343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82348       };
82349     }
82350   }
82351
82352   jresult = (void *)result;
82353   return jresult;
82354 }
82355
82356
82357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82358   void * jresult ;
82359   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82360   Dali::Toolkit::VideoView *arg2 = 0 ;
82361   Dali::Toolkit::VideoView *result = 0 ;
82362
82363   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82364   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82365   if (!arg2) {
82366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82367     return 0;
82368   }
82369   {
82370     try {
82371       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82372     } catch (std::out_of_range& e) {
82373       {
82374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82375       };
82376     } catch (std::exception& e) {
82377       {
82378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82379       };
82380     } catch (Dali::DaliException e) {
82381       {
82382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82383       };
82384     } catch (...) {
82385       {
82386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82387       };
82388     }
82389   }
82390
82391   jresult = (void *)result;
82392   return jresult;
82393 }
82394
82395
82396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82397   void * jresult ;
82398   Dali::BaseHandle arg1 ;
82399   Dali::BaseHandle *argp1 ;
82400   Dali::Toolkit::VideoView result;
82401
82402   argp1 = (Dali::BaseHandle *)jarg1;
82403   if (!argp1) {
82404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82405     return 0;
82406   }
82407   arg1 = *argp1;
82408   {
82409     try {
82410       result = Dali::Toolkit::VideoView::DownCast(arg1);
82411     } catch (std::out_of_range& e) {
82412       {
82413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82414       };
82415     } catch (std::exception& e) {
82416       {
82417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82418       };
82419     } catch (Dali::DaliException e) {
82420       {
82421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82422       };
82423     } catch (...) {
82424       {
82425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82426       };
82427     }
82428   }
82429
82430   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82431   return jresult;
82432 }
82433
82434
82435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82436   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82437
82438   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82439   {
82440     try {
82441       (arg1)->Play();
82442     } catch (std::out_of_range& e) {
82443       {
82444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82445       };
82446     } catch (std::exception& e) {
82447       {
82448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82449       };
82450     } catch (Dali::DaliException e) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82453       };
82454     } catch (...) {
82455       {
82456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82457       };
82458     }
82459   }
82460
82461 }
82462
82463
82464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82465   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82466
82467   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82468   {
82469     try {
82470       (arg1)->Pause();
82471     } catch (std::out_of_range& e) {
82472       {
82473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82474       };
82475     } catch (std::exception& e) {
82476       {
82477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82478       };
82479     } catch (Dali::DaliException e) {
82480       {
82481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82482       };
82483     } catch (...) {
82484       {
82485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82486       };
82487     }
82488   }
82489
82490 }
82491
82492
82493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82494   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82495
82496   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82497   {
82498     try {
82499       (arg1)->Stop();
82500     } catch (std::out_of_range& e) {
82501       {
82502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82503       };
82504     } catch (std::exception& e) {
82505       {
82506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82507       };
82508     } catch (Dali::DaliException e) {
82509       {
82510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82511       };
82512     } catch (...) {
82513       {
82514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82515       };
82516     }
82517   }
82518
82519 }
82520
82521
82522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82523   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82524   int arg2 ;
82525
82526   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82527   arg2 = (int)jarg2;
82528   {
82529     try {
82530       (arg1)->Forward(arg2);
82531     } catch (std::out_of_range& e) {
82532       {
82533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82534       };
82535     } catch (std::exception& e) {
82536       {
82537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82538       };
82539     } catch (Dali::DaliException e) {
82540       {
82541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82542       };
82543     } catch (...) {
82544       {
82545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82546       };
82547     }
82548   }
82549
82550 }
82551
82552
82553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82554   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82555   int arg2 ;
82556
82557   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82558   arg2 = (int)jarg2;
82559   {
82560     try {
82561       (arg1)->Backward(arg2);
82562     } catch (std::out_of_range& e) {
82563       {
82564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82565       };
82566     } catch (std::exception& e) {
82567       {
82568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82569       };
82570     } catch (Dali::DaliException e) {
82571       {
82572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82573       };
82574     } catch (...) {
82575       {
82576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82577       };
82578     }
82579   }
82580
82581 }
82582
82583
82584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82585   void * jresult ;
82586   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82587   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82588
82589   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82590   {
82591     try {
82592       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82593     } catch (std::out_of_range& e) {
82594       {
82595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82596       };
82597     } catch (std::exception& e) {
82598       {
82599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82600       };
82601     } catch (Dali::DaliException e) {
82602       {
82603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82604       };
82605     } catch (...) {
82606       {
82607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82608       };
82609     }
82610   }
82611
82612   jresult = (void *)result;
82613   return jresult;
82614 }
82615
82616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82617 {
82618   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82619   if( arg1 == nullptr )
82620   {
82621     DALI_LOG_ERROR("VideoView is nullptr!");
82622     return nullptr;
82623   }
82624   void * ret = nullptr;
82625   {
82626     try{
82627
82628       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82629       ret = Dali::AnyCast< void * >( result );
82630
82631     } catch (std::out_of_range& e) {
82632       {
82633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (std::exception& e) {
82636       {
82637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82638       };
82639     } catch (Dali::DaliException e) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82642       };
82643     } catch (...) {
82644       {
82645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82646       };
82647     }
82648   }
82649   return ret;
82650 }
82651
82652
82653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82654   int jresult ;
82655   int result;
82656
82657   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82658   jresult = (int)result;
82659   return jresult;
82660 }
82661
82662
82663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82664   int jresult ;
82665   int result;
82666
82667   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82668   jresult = (int)result;
82669   return jresult;
82670 }
82671
82672
82673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82674   int jresult ;
82675   int result;
82676
82677   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82678   jresult = (int)result;
82679   return jresult;
82680 }
82681
82682
82683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82684   int jresult ;
82685   int result;
82686
82687   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82688   jresult = (int)result;
82689   return jresult;
82690 }
82691
82692
82693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82694   int jresult ;
82695   int result;
82696
82697   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82698   jresult = (int)result;
82699   return jresult;
82700 }
82701
82702
82703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82704   int jresult ;
82705   int result;
82706
82707   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82708   jresult = (int)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82714   int jresult ;
82715   int result;
82716
82717   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82718   jresult = (int)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82724   int jresult ;
82725   int result;
82726
82727   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82728   jresult = (int)result;
82729   return jresult;
82730 }
82731
82732
82733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82734   int jresult ;
82735   int result;
82736
82737   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82738   jresult = (int)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82744   int jresult ;
82745   int result;
82746
82747   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82748   jresult = (int)result;
82749   return jresult;
82750 }
82751
82752
82753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82754   int jresult ;
82755   int result;
82756
82757   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82758   jresult = (int)result;
82759   return jresult;
82760 }
82761
82762
82763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82764   int jresult ;
82765   int result;
82766
82767   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82768   jresult = (int)result;
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82774   int jresult ;
82775   int result;
82776
82777   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82778   jresult = (int)result;
82779   return jresult;
82780 }
82781
82782
82783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82784   int jresult ;
82785   int result;
82786
82787   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82788   jresult = (int)result;
82789   return jresult;
82790 }
82791
82792
82793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82794   int jresult ;
82795   int result;
82796
82797   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82798   jresult = (int)result;
82799   return jresult;
82800 }
82801
82802
82803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82804   int jresult ;
82805   int result;
82806
82807   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82808   jresult = (int)result;
82809   return jresult;
82810 }
82811
82812
82813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82814   int jresult ;
82815   int result;
82816
82817   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82818   jresult = (int)result;
82819   return jresult;
82820 }
82821
82822
82823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82824   int jresult ;
82825   int result;
82826
82827   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82828   jresult = (int)result;
82829   return jresult;
82830 }
82831
82832
82833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82834   int jresult ;
82835   int result;
82836
82837   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82838   jresult = (int)result;
82839   return jresult;
82840 }
82841
82842
82843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82844   int jresult ;
82845   int result;
82846
82847   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82848   jresult = (int)result;
82849   return jresult;
82850 }
82851
82852
82853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82854   int jresult ;
82855   int result;
82856
82857   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82858   jresult = (int)result;
82859   return jresult;
82860 }
82861
82862
82863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82864   void * jresult ;
82865   Dali::Toolkit::Popup::Property *result = 0 ;
82866
82867   {
82868     try {
82869       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82870     } catch (std::out_of_range& e) {
82871       {
82872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82873       };
82874     } catch (std::exception& e) {
82875       {
82876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82877       };
82878     } catch (Dali::DaliException e) {
82879       {
82880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82881       };
82882     } catch (...) {
82883       {
82884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82885       };
82886     }
82887   }
82888
82889   jresult = (void *)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82895   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82896
82897   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82898   {
82899     try {
82900       delete arg1;
82901     } catch (std::out_of_range& e) {
82902       {
82903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82904       };
82905     } catch (std::exception& e) {
82906       {
82907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82908       };
82909     } catch (Dali::DaliException e) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82916       };
82917     }
82918   }
82919
82920 }
82921
82922
82923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82924   void * jresult ;
82925   Dali::Toolkit::Popup *result = 0 ;
82926
82927   {
82928     try {
82929       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82930     } catch (std::out_of_range& e) {
82931       {
82932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82933       };
82934     } catch (std::exception& e) {
82935       {
82936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82937       };
82938     } catch (Dali::DaliException e) {
82939       {
82940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82941       };
82942     } catch (...) {
82943       {
82944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82945       };
82946     }
82947   }
82948
82949   jresult = (void *)result;
82950   return jresult;
82951 }
82952
82953
82954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82955   void * jresult ;
82956   Dali::Toolkit::Popup result;
82957
82958   {
82959     try {
82960       result = Dali::Toolkit::Popup::New();
82961     } catch (std::out_of_range& e) {
82962       {
82963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82964       };
82965     } catch (std::exception& e) {
82966       {
82967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82968       };
82969     } catch (Dali::DaliException e) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82972       };
82973     } catch (...) {
82974       {
82975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82976       };
82977     }
82978   }
82979
82980   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82981   return jresult;
82982 }
82983
82984
82985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82986   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82987
82988   arg1 = (Dali::Toolkit::Popup *)jarg1;
82989   {
82990     try {
82991       delete arg1;
82992     } catch (std::out_of_range& e) {
82993       {
82994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82995       };
82996     } catch (std::exception& e) {
82997       {
82998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82999       };
83000     } catch (Dali::DaliException e) {
83001       {
83002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83003       };
83004     } catch (...) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83007       };
83008     }
83009   }
83010
83011 }
83012
83013
83014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83015   void * jresult ;
83016   Dali::Toolkit::Popup *arg1 = 0 ;
83017   Dali::Toolkit::Popup *result = 0 ;
83018
83019   arg1 = (Dali::Toolkit::Popup *)jarg1;
83020   if (!arg1) {
83021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83022     return 0;
83023   }
83024   {
83025     try {
83026       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83027     } catch (std::out_of_range& e) {
83028       {
83029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83030       };
83031     } catch (std::exception& e) {
83032       {
83033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83034       };
83035     } catch (Dali::DaliException e) {
83036       {
83037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83038       };
83039     } catch (...) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83042       };
83043     }
83044   }
83045
83046   jresult = (void *)result;
83047   return jresult;
83048 }
83049
83050
83051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83052   void * jresult ;
83053   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83054   Dali::Toolkit::Popup *arg2 = 0 ;
83055   Dali::Toolkit::Popup *result = 0 ;
83056
83057   arg1 = (Dali::Toolkit::Popup *)jarg1;
83058   arg2 = (Dali::Toolkit::Popup *)jarg2;
83059   if (!arg2) {
83060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83061     return 0;
83062   }
83063   {
83064     try {
83065       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83066     } catch (std::out_of_range& e) {
83067       {
83068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83069       };
83070     } catch (std::exception& e) {
83071       {
83072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83073       };
83074     } catch (Dali::DaliException e) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83077       };
83078     } catch (...) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83081       };
83082     }
83083   }
83084
83085   jresult = (void *)result;
83086   return jresult;
83087 }
83088
83089
83090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83091   void * jresult ;
83092   Dali::BaseHandle arg1 ;
83093   Dali::BaseHandle *argp1 ;
83094   Dali::Toolkit::Popup result;
83095
83096   argp1 = (Dali::BaseHandle *)jarg1;
83097   if (!argp1) {
83098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83099     return 0;
83100   }
83101   arg1 = *argp1;
83102   {
83103     try {
83104       result = Dali::Toolkit::Popup::DownCast(arg1);
83105     } catch (std::out_of_range& e) {
83106       {
83107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83108       };
83109     } catch (std::exception& e) {
83110       {
83111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83112       };
83113     } catch (Dali::DaliException e) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83120       };
83121     }
83122   }
83123
83124   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83125   return jresult;
83126 }
83127
83128
83129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83130   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83131   Dali::Actor arg2 ;
83132   Dali::Actor *argp2 ;
83133
83134   arg1 = (Dali::Toolkit::Popup *)jarg1;
83135   argp2 = (Dali::Actor *)jarg2;
83136   if (!argp2) {
83137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83138     return ;
83139   }
83140   arg2 = *argp2;
83141   {
83142     try {
83143       (arg1)->SetTitle(arg2);
83144     } catch (std::out_of_range& e) {
83145       {
83146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83147       };
83148     } catch (std::exception& e) {
83149       {
83150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83151       };
83152     } catch (Dali::DaliException e) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83155       };
83156     } catch (...) {
83157       {
83158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83159       };
83160     }
83161   }
83162
83163 }
83164
83165
83166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83167   void * jresult ;
83168   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83169   Dali::Actor result;
83170
83171   arg1 = (Dali::Toolkit::Popup *)jarg1;
83172   {
83173     try {
83174       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83175     } catch (std::out_of_range& e) {
83176       {
83177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83178       };
83179     } catch (std::exception& e) {
83180       {
83181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83182       };
83183     } catch (Dali::DaliException e) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83186       };
83187     } catch (...) {
83188       {
83189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83190       };
83191     }
83192   }
83193
83194   jresult = new Dali::Actor((const Dali::Actor &)result);
83195   return jresult;
83196 }
83197
83198
83199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83200   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83201   Dali::Actor arg2 ;
83202   Dali::Actor *argp2 ;
83203
83204   arg1 = (Dali::Toolkit::Popup *)jarg1;
83205   argp2 = (Dali::Actor *)jarg2;
83206   if (!argp2) {
83207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83208     return ;
83209   }
83210   arg2 = *argp2;
83211   {
83212     try {
83213       (arg1)->SetContent(arg2);
83214     } catch (std::out_of_range& e) {
83215       {
83216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83217       };
83218     } catch (std::exception& e) {
83219       {
83220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83221       };
83222     } catch (Dali::DaliException e) {
83223       {
83224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83225       };
83226     } catch (...) {
83227       {
83228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83229       };
83230     }
83231   }
83232
83233 }
83234
83235
83236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83237   void * jresult ;
83238   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83239   Dali::Actor result;
83240
83241   arg1 = (Dali::Toolkit::Popup *)jarg1;
83242   {
83243     try {
83244       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (Dali::DaliException e) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83260       };
83261     }
83262   }
83263
83264   jresult = new Dali::Actor((const Dali::Actor &)result);
83265   return jresult;
83266 }
83267
83268
83269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83270   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83271   Dali::Actor arg2 ;
83272   Dali::Actor *argp2 ;
83273
83274   arg1 = (Dali::Toolkit::Popup *)jarg1;
83275   argp2 = (Dali::Actor *)jarg2;
83276   if (!argp2) {
83277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83278     return ;
83279   }
83280   arg2 = *argp2;
83281   {
83282     try {
83283       (arg1)->SetFooter(arg2);
83284     } catch (std::out_of_range& e) {
83285       {
83286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83287       };
83288     } catch (std::exception& e) {
83289       {
83290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83291       };
83292     } catch (Dali::DaliException e) {
83293       {
83294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83295       };
83296     } catch (...) {
83297       {
83298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83299       };
83300     }
83301   }
83302
83303 }
83304
83305
83306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83307   void * jresult ;
83308   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83309   Dali::Actor result;
83310
83311   arg1 = (Dali::Toolkit::Popup *)jarg1;
83312   {
83313     try {
83314       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83315     } catch (std::out_of_range& e) {
83316       {
83317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83318       };
83319     } catch (std::exception& e) {
83320       {
83321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83322       };
83323     } catch (Dali::DaliException e) {
83324       {
83325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83326       };
83327     } catch (...) {
83328       {
83329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83330       };
83331     }
83332   }
83333
83334   jresult = new Dali::Actor((const Dali::Actor &)result);
83335   return jresult;
83336 }
83337
83338
83339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83340   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83341   Dali::Toolkit::Popup::DisplayState arg2 ;
83342
83343   arg1 = (Dali::Toolkit::Popup *)jarg1;
83344   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83345   {
83346     try {
83347       (arg1)->SetDisplayState(arg2);
83348     } catch (std::out_of_range& e) {
83349       {
83350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83351       };
83352     } catch (std::exception& e) {
83353       {
83354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83355       };
83356     } catch (Dali::DaliException e) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83359       };
83360     } catch (...) {
83361       {
83362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83363       };
83364     }
83365   }
83366
83367 }
83368
83369
83370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83371   int jresult ;
83372   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83373   Dali::Toolkit::Popup::DisplayState result;
83374
83375   arg1 = (Dali::Toolkit::Popup *)jarg1;
83376   {
83377     try {
83378       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (Dali::DaliException e) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83394       };
83395     }
83396   }
83397
83398   jresult = (int)result;
83399   return jresult;
83400 }
83401
83402
83403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83404   void * jresult ;
83405   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83406   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83407
83408   arg1 = (Dali::Toolkit::Popup *)jarg1;
83409   {
83410     try {
83411       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83412     } catch (std::out_of_range& e) {
83413       {
83414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83415       };
83416     } catch (std::exception& e) {
83417       {
83418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83419       };
83420     } catch (Dali::DaliException e) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83423       };
83424     } catch (...) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83427       };
83428     }
83429   }
83430
83431   jresult = (void *)result;
83432   return jresult;
83433 }
83434
83435
83436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83437   void * jresult ;
83438   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83439   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83440
83441   arg1 = (Dali::Toolkit::Popup *)jarg1;
83442   {
83443     try {
83444       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83445     } catch (std::out_of_range& e) {
83446       {
83447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (std::exception& e) {
83450       {
83451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (Dali::DaliException e) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83460       };
83461     }
83462   }
83463
83464   jresult = (void *)result;
83465   return jresult;
83466 }
83467
83468
83469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83470   void * jresult ;
83471   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83472   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83473
83474   arg1 = (Dali::Toolkit::Popup *)jarg1;
83475   {
83476     try {
83477       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83478     } catch (std::out_of_range& e) {
83479       {
83480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83481       };
83482     } catch (std::exception& e) {
83483       {
83484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83485       };
83486     } catch (Dali::DaliException e) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83489       };
83490     } catch (...) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83493       };
83494     }
83495   }
83496
83497   jresult = (void *)result;
83498   return jresult;
83499 }
83500
83501
83502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83503   void * jresult ;
83504   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83505   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83506
83507   arg1 = (Dali::Toolkit::Popup *)jarg1;
83508   {
83509     try {
83510       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83511     } catch (std::out_of_range& e) {
83512       {
83513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83514       };
83515     } catch (std::exception& e) {
83516       {
83517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (Dali::DaliException e) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83522       };
83523     } catch (...) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83526       };
83527     }
83528   }
83529
83530   jresult = (void *)result;
83531   return jresult;
83532 }
83533
83534
83535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83536   void * jresult ;
83537   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83538   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83539
83540   arg1 = (Dali::Toolkit::Popup *)jarg1;
83541   {
83542     try {
83543       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83544     } catch (std::out_of_range& e) {
83545       {
83546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83547       };
83548     } catch (std::exception& e) {
83549       {
83550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83551       };
83552     } catch (Dali::DaliException e) {
83553       {
83554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83555       };
83556     } catch (...) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83559       };
83560     }
83561   }
83562
83563   jresult = (void *)result;
83564   return jresult;
83565 }
83566
83567
83568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83569   int jresult ;
83570   int result;
83571
83572   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83573   jresult = (int)result;
83574   return jresult;
83575 }
83576
83577
83578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83579   int jresult ;
83580   int result;
83581
83582   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83583   jresult = (int)result;
83584   return jresult;
83585 }
83586
83587
83588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83589   int jresult ;
83590   int result;
83591
83592   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83593   jresult = (int)result;
83594   return jresult;
83595 }
83596
83597
83598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83599   int jresult ;
83600   int result;
83601
83602   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83603   jresult = (int)result;
83604   return jresult;
83605 }
83606
83607
83608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83609   int jresult ;
83610   int result;
83611
83612   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83613   jresult = (int)result;
83614   return jresult;
83615 }
83616
83617
83618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83619   int jresult ;
83620   int result;
83621
83622   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83623   jresult = (int)result;
83624   return jresult;
83625 }
83626
83627
83628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83629   int jresult ;
83630   int result;
83631
83632   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83633   jresult = (int)result;
83634   return jresult;
83635 }
83636
83637
83638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83639   int jresult ;
83640   int result;
83641
83642   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83643   jresult = (int)result;
83644   return jresult;
83645 }
83646
83647
83648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83649   int jresult ;
83650   int result;
83651
83652   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83653   jresult = (int)result;
83654   return jresult;
83655 }
83656
83657
83658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83659   void * jresult ;
83660   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83661
83662   {
83663     try {
83664       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83665     } catch (std::out_of_range& e) {
83666       {
83667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83668       };
83669     } catch (std::exception& e) {
83670       {
83671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83672       };
83673     } catch (Dali::DaliException e) {
83674       {
83675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83676       };
83677     } catch (...) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83680       };
83681     }
83682   }
83683
83684   jresult = (void *)result;
83685   return jresult;
83686 }
83687
83688
83689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83690   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83691
83692   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83693   {
83694     try {
83695       delete arg1;
83696     } catch (std::out_of_range& e) {
83697       {
83698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83699       };
83700     } catch (std::exception& e) {
83701       {
83702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83703       };
83704     } catch (Dali::DaliException e) {
83705       {
83706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83707       };
83708     } catch (...) {
83709       {
83710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83711       };
83712     }
83713   }
83714
83715 }
83716
83717
83718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83719   void * jresult ;
83720   Dali::Toolkit::ProgressBar result;
83721
83722   {
83723     try {
83724       result = Dali::Toolkit::ProgressBar::New();
83725     } catch (std::out_of_range& e) {
83726       {
83727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83728       };
83729     } catch (std::exception& e) {
83730       {
83731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83732       };
83733     } catch (Dali::DaliException e) {
83734       {
83735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83736       };
83737     } catch (...) {
83738       {
83739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83740       };
83741     }
83742   }
83743
83744   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83745   return jresult;
83746 }
83747
83748
83749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83750   void * jresult ;
83751   Dali::Toolkit::ProgressBar *result = 0 ;
83752
83753   {
83754     try {
83755       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83756     } catch (std::out_of_range& e) {
83757       {
83758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83759       };
83760     } catch (std::exception& e) {
83761       {
83762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83763       };
83764     } catch (Dali::DaliException e) {
83765       {
83766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83767       };
83768     } catch (...) {
83769       {
83770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83771       };
83772     }
83773   }
83774
83775   jresult = (void *)result;
83776   return jresult;
83777 }
83778
83779
83780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83781   void * jresult ;
83782   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83783   Dali::Toolkit::ProgressBar *result = 0 ;
83784
83785   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83786   if (!arg1) {
83787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83788     return 0;
83789   }
83790   {
83791     try {
83792       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83793     } catch (std::out_of_range& e) {
83794       {
83795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83796       };
83797     } catch (std::exception& e) {
83798       {
83799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83800       };
83801     } catch (Dali::DaliException e) {
83802       {
83803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83804       };
83805     } catch (...) {
83806       {
83807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83808       };
83809     }
83810   }
83811
83812   jresult = (void *)result;
83813   return jresult;
83814 }
83815
83816
83817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83818   void * jresult ;
83819   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83820   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83821   Dali::Toolkit::ProgressBar *result = 0 ;
83822
83823   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83824   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83825   if (!arg2) {
83826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83827     return 0;
83828   }
83829   {
83830     try {
83831       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83832     } catch (std::out_of_range& e) {
83833       {
83834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83835       };
83836     } catch (std::exception& e) {
83837       {
83838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83839       };
83840     } catch (Dali::DaliException e) {
83841       {
83842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83843       };
83844     } catch (...) {
83845       {
83846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83847       };
83848     }
83849   }
83850
83851   jresult = (void *)result;
83852   return jresult;
83853 }
83854
83855
83856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83857   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83858
83859   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83860   {
83861     try {
83862       delete arg1;
83863     } catch (std::out_of_range& e) {
83864       {
83865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83866       };
83867     } catch (std::exception& e) {
83868       {
83869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83870       };
83871     } catch (Dali::DaliException e) {
83872       {
83873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83874       };
83875     } catch (...) {
83876       {
83877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83878       };
83879     }
83880   }
83881
83882 }
83883
83884
83885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83886   void * jresult ;
83887   Dali::BaseHandle arg1 ;
83888   Dali::BaseHandle *argp1 ;
83889   Dali::Toolkit::ProgressBar result;
83890
83891   argp1 = (Dali::BaseHandle *)jarg1;
83892   if (!argp1) {
83893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83894     return 0;
83895   }
83896   arg1 = *argp1;
83897   {
83898     try {
83899       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83900     } catch (std::out_of_range& e) {
83901       {
83902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83903       };
83904     } catch (std::exception& e) {
83905       {
83906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83907       };
83908     } catch (Dali::DaliException e) {
83909       {
83910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83911       };
83912     } catch (...) {
83913       {
83914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83915       };
83916     }
83917   }
83918
83919   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83920   return jresult;
83921 }
83922
83923
83924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83925   void * jresult ;
83926   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83927   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83928
83929   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83930   {
83931     try {
83932       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83933     } catch (std::out_of_range& e) {
83934       {
83935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83936       };
83937     } catch (std::exception& e) {
83938       {
83939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (Dali::DaliException e) {
83942       {
83943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83948       };
83949     }
83950   }
83951
83952   jresult = (void *)result;
83953   return jresult;
83954 }
83955
83956
83957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83958   void * jresult ;
83959   Dali::Toolkit::GaussianBlurView *result = 0 ;
83960
83961   {
83962     try {
83963       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83964     } catch (std::out_of_range& e) {
83965       {
83966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83967       };
83968     } catch (std::exception& e) {
83969       {
83970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83971       };
83972     } catch (Dali::DaliException e) {
83973       {
83974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83975       };
83976     } catch (...) {
83977       {
83978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83979       };
83980     }
83981   }
83982
83983   jresult = (void *)result;
83984   return jresult;
83985 }
83986
83987
83988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83989   void * jresult ;
83990   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83991   Dali::Toolkit::GaussianBlurView *result = 0 ;
83992
83993   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83994   if (!arg1) {
83995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83996     return 0;
83997   }
83998   {
83999     try {
84000       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
84001     } catch (std::out_of_range& e) {
84002       {
84003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84004       };
84005     } catch (std::exception& e) {
84006       {
84007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84008       };
84009     } catch (Dali::DaliException e) {
84010       {
84011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84012       };
84013     } catch (...) {
84014       {
84015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84016       };
84017     }
84018   }
84019
84020   jresult = (void *)result;
84021   return jresult;
84022 }
84023
84024
84025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
84026   void * jresult ;
84027   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84028   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
84029   Dali::Toolkit::GaussianBlurView *result = 0 ;
84030
84031   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84032   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
84033   if (!arg2) {
84034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84035     return 0;
84036   }
84037   {
84038     try {
84039       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
84040     } catch (std::out_of_range& e) {
84041       {
84042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84043       };
84044     } catch (std::exception& e) {
84045       {
84046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84047       };
84048     } catch (Dali::DaliException e) {
84049       {
84050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84051       };
84052     } catch (...) {
84053       {
84054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84055       };
84056     }
84057   }
84058
84059   jresult = (void *)result;
84060   return jresult;
84061 }
84062
84063
84064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
84065   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84066
84067   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84068   {
84069     try {
84070       delete arg1;
84071     } catch (std::out_of_range& e) {
84072       {
84073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84074       };
84075     } catch (std::exception& e) {
84076       {
84077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84078       };
84079     } catch (Dali::DaliException e) {
84080       {
84081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84082       };
84083     } catch (...) {
84084       {
84085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84086       };
84087     }
84088   }
84089
84090 }
84091
84092
84093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
84094   void * jresult ;
84095   Dali::BaseHandle arg1 ;
84096   Dali::BaseHandle *argp1 ;
84097   Dali::Toolkit::GaussianBlurView result;
84098
84099   argp1 = (Dali::BaseHandle *)jarg1;
84100   if (!argp1) {
84101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84102     return 0;
84103   }
84104   arg1 = *argp1;
84105   {
84106     try {
84107       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
84108     } catch (std::out_of_range& e) {
84109       {
84110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84111       };
84112     } catch (std::exception& e) {
84113       {
84114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84115       };
84116     } catch (Dali::DaliException e) {
84117       {
84118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84119       };
84120     } catch (...) {
84121       {
84122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84123       };
84124     }
84125   }
84126
84127   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84133   void * jresult ;
84134   Dali::Toolkit::GaussianBlurView result;
84135
84136   {
84137     try {
84138       result = Dali::Toolkit::GaussianBlurView::New();
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 (Dali::DaliException e) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84150       };
84151     } catch (...) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84154       };
84155     }
84156   }
84157
84158   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84159   return jresult;
84160 }
84161
84162
84163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84164   void * jresult ;
84165   unsigned int arg1 ;
84166   float arg2 ;
84167   Dali::Pixel::Format arg3 ;
84168   float arg4 ;
84169   float arg5 ;
84170   bool arg6 ;
84171   Dali::Toolkit::GaussianBlurView result;
84172
84173   arg1 = (unsigned int)jarg1;
84174   arg2 = (float)jarg2;
84175   arg3 = (Dali::Pixel::Format)jarg3;
84176   arg4 = (float)jarg4;
84177   arg5 = (float)jarg5;
84178   arg6 = jarg6 ? true : false;
84179   {
84180     try {
84181       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84182     } catch (std::out_of_range& e) {
84183       {
84184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84185       };
84186     } catch (std::exception& e) {
84187       {
84188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84189       };
84190     } catch (Dali::DaliException e) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84193       };
84194     } catch (...) {
84195       {
84196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84197       };
84198     }
84199   }
84200
84201   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84202   return jresult;
84203 }
84204
84205
84206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84207   void * jresult ;
84208   unsigned int arg1 ;
84209   float arg2 ;
84210   Dali::Pixel::Format arg3 ;
84211   float arg4 ;
84212   float arg5 ;
84213   Dali::Toolkit::GaussianBlurView result;
84214
84215   arg1 = (unsigned int)jarg1;
84216   arg2 = (float)jarg2;
84217   arg3 = (Dali::Pixel::Format)jarg3;
84218   arg4 = (float)jarg4;
84219   arg5 = (float)jarg5;
84220   {
84221     try {
84222       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84223     } catch (std::out_of_range& e) {
84224       {
84225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (std::exception& e) {
84228       {
84229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (Dali::DaliException e) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84234       };
84235     } catch (...) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84238       };
84239     }
84240   }
84241
84242   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84243   return jresult;
84244 }
84245
84246
84247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84248   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84249   Dali::Actor arg2 ;
84250   Dali::Actor *argp2 ;
84251
84252   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84253   argp2 = (Dali::Actor *)jarg2;
84254   if (!argp2) {
84255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84256     return ;
84257   }
84258   arg2 = *argp2;
84259   {
84260     try {
84261       (arg1)->Add(arg2);
84262     } catch (std::out_of_range& e) {
84263       {
84264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84265       };
84266     } catch (std::exception& e) {
84267       {
84268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84269       };
84270     } catch (Dali::DaliException e) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84273       };
84274     } catch (...) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84277       };
84278     }
84279   }
84280
84281 }
84282
84283
84284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84285   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84286   Dali::Actor arg2 ;
84287   Dali::Actor *argp2 ;
84288
84289   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84290   argp2 = (Dali::Actor *)jarg2;
84291   if (!argp2) {
84292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84293     return ;
84294   }
84295   arg2 = *argp2;
84296   {
84297     try {
84298       (arg1)->Remove(arg2);
84299     } catch (std::out_of_range& e) {
84300       {
84301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84302       };
84303     } catch (std::exception& e) {
84304       {
84305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84306       };
84307     } catch (Dali::DaliException e) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84310       };
84311     } catch (...) {
84312       {
84313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84314       };
84315     }
84316   }
84317
84318 }
84319
84320
84321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84322   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84323
84324   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84325   {
84326     try {
84327       (arg1)->Activate();
84328     } catch (std::out_of_range& e) {
84329       {
84330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84331       };
84332     } catch (std::exception& e) {
84333       {
84334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84335       };
84336     } catch (Dali::DaliException e) {
84337       {
84338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84339       };
84340     } catch (...) {
84341       {
84342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84343       };
84344     }
84345   }
84346
84347 }
84348
84349
84350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84351   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84352
84353   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84354   {
84355     try {
84356       (arg1)->ActivateOnce();
84357     } catch (std::out_of_range& e) {
84358       {
84359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84360       };
84361     } catch (std::exception& e) {
84362       {
84363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84364       };
84365     } catch (Dali::DaliException e) {
84366       {
84367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84368       };
84369     } catch (...) {
84370       {
84371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84372       };
84373     }
84374   }
84375
84376 }
84377
84378
84379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84380   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84381
84382   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84383   {
84384     try {
84385       (arg1)->Deactivate();
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84393       };
84394     } catch (Dali::DaliException e) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84397       };
84398     } catch (...) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84401       };
84402     }
84403   }
84404
84405 }
84406
84407
84408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84409   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84410   Dali::Texture arg2 ;
84411   Dali::FrameBuffer arg3 ;
84412   Dali::Texture *argp2 ;
84413   Dali::FrameBuffer *argp3 ;
84414
84415   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84416   argp2 = (Dali::Texture *)jarg2;
84417   if (!argp2) {
84418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84419     return ;
84420   }
84421   arg2 = *argp2;
84422   argp3 = (Dali::FrameBuffer *)jarg3;
84423   if (!argp3) {
84424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84425     return ;
84426   }
84427   arg3 = *argp3;
84428   {
84429     try {
84430       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84431     } catch (std::out_of_range& e) {
84432       {
84433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84434       };
84435     } catch (std::exception& e) {
84436       {
84437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (Dali::DaliException e) {
84440       {
84441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84446       };
84447     }
84448   }
84449
84450 }
84451
84452
84453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84454   int jresult ;
84455   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84456   Dali::Property::Index result;
84457
84458   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84459   {
84460     try {
84461       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84462     } catch (std::out_of_range& e) {
84463       {
84464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (std::exception& e) {
84467       {
84468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84469       };
84470     } catch (Dali::DaliException e) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84473       };
84474     } catch (...) {
84475       {
84476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84477       };
84478     }
84479   }
84480
84481   jresult = result;
84482   return jresult;
84483 }
84484
84485
84486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84487   void * jresult ;
84488   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84489   Dali::FrameBuffer result;
84490
84491   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84492   {
84493     try {
84494       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84495     } catch (std::out_of_range& e) {
84496       {
84497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (std::exception& e) {
84500       {
84501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (Dali::DaliException e) {
84504       {
84505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84506       };
84507     } catch (...) {
84508       {
84509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84510       };
84511     }
84512   }
84513
84514   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84515   return jresult;
84516 }
84517
84518
84519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84520   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84521   Dali::Vector4 *arg2 = 0 ;
84522
84523   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84524   arg2 = (Dali::Vector4 *)jarg2;
84525   if (!arg2) {
84526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84527     return ;
84528   }
84529   {
84530     try {
84531       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84532     } catch (std::out_of_range& e) {
84533       {
84534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84535       };
84536     } catch (std::exception& e) {
84537       {
84538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84539       };
84540     } catch (Dali::DaliException e) {
84541       {
84542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84543       };
84544     } catch (...) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84547       };
84548     }
84549   }
84550
84551 }
84552
84553
84554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84555   void * jresult ;
84556   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84557   Dali::Vector4 result;
84558
84559   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84560   {
84561     try {
84562       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
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 (Dali::DaliException e) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84574       };
84575     } catch (...) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84578       };
84579     }
84580   }
84581
84582   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84583   return jresult;
84584 }
84585
84586
84587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84588   void * jresult ;
84589   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84590   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84591
84592   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84593   {
84594     try {
84595       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84596     } catch (std::out_of_range& e) {
84597       {
84598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (std::exception& e) {
84601       {
84602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84603       };
84604     } catch (Dali::DaliException e) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84607       };
84608     } catch (...) {
84609       {
84610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84611       };
84612     }
84613   }
84614
84615   jresult = (void *)result;
84616   return jresult;
84617 }
84618
84619
84620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84621   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84622
84623   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84624   {
84625     try {
84626       delete arg1;
84627     } catch (std::out_of_range& e) {
84628       {
84629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84630       };
84631     } catch (std::exception& e) {
84632       {
84633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84634       };
84635     } catch (Dali::DaliException e) {
84636       {
84637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84642       };
84643     }
84644   }
84645
84646 }
84647
84648
84649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84650   unsigned int jresult ;
84651   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84652   unsigned int result;
84653
84654   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84655   {
84656     try {
84657       result = (unsigned int)(arg1)->GetNumberOfPages();
84658     } catch (std::out_of_range& e) {
84659       {
84660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84661       };
84662     } catch (std::exception& e) {
84663       {
84664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84665       };
84666     } catch (Dali::DaliException e) {
84667       {
84668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84669       };
84670     } catch (...) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84673       };
84674     }
84675   }
84676
84677   jresult = result;
84678   return jresult;
84679 }
84680
84681
84682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84683   void * jresult ;
84684   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84685   unsigned int arg2 ;
84686   Dali::Texture result;
84687
84688   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84689   arg2 = (unsigned int)jarg2;
84690   {
84691     try {
84692       result = (arg1)->NewPage(arg2);
84693     } catch (std::out_of_range& e) {
84694       {
84695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84696       };
84697     } catch (std::exception& e) {
84698       {
84699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84700       };
84701     } catch (Dali::DaliException e) {
84702       {
84703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84704       };
84705     } catch (...) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84708       };
84709     }
84710   }
84711
84712   jresult = new Dali::Texture((const Dali::Texture &)result);
84713   return jresult;
84714 }
84715
84716
84717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84718   int jresult ;
84719   int result;
84720
84721   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84722   jresult = (int)result;
84723   return jresult;
84724 }
84725
84726
84727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84728   int jresult ;
84729   int result;
84730
84731   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84732   jresult = (int)result;
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84738   int jresult ;
84739   int result;
84740
84741   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84742   jresult = (int)result;
84743   return jresult;
84744 }
84745
84746
84747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84748   void * jresult ;
84749   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84750
84751   {
84752     try {
84753       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84754     } catch (std::out_of_range& e) {
84755       {
84756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84757       };
84758     } catch (std::exception& e) {
84759       {
84760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84761       };
84762     } catch (Dali::DaliException e) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84765       };
84766     } catch (...) {
84767       {
84768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84769       };
84770     }
84771   }
84772
84773   jresult = (void *)result;
84774   return jresult;
84775 }
84776
84777
84778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84779   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84780
84781   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84782   {
84783     try {
84784       delete arg1;
84785     } catch (std::out_of_range& e) {
84786       {
84787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84788       };
84789     } catch (std::exception& e) {
84790       {
84791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84792       };
84793     } catch (Dali::DaliException e) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84800       };
84801     }
84802   }
84803
84804 }
84805
84806
84807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84808   void * jresult ;
84809   Dali::Toolkit::PageTurnView *result = 0 ;
84810
84811   {
84812     try {
84813       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84814     } catch (std::out_of_range& e) {
84815       {
84816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84817       };
84818     } catch (std::exception& e) {
84819       {
84820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84821       };
84822     } catch (Dali::DaliException e) {
84823       {
84824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84825       };
84826     } catch (...) {
84827       {
84828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84829       };
84830     }
84831   }
84832
84833   jresult = (void *)result;
84834   return jresult;
84835 }
84836
84837
84838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84839   void * jresult ;
84840   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84841   Dali::Toolkit::PageTurnView *result = 0 ;
84842
84843   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84844   if (!arg1) {
84845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84846     return 0;
84847   }
84848   {
84849     try {
84850       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84851     } catch (std::out_of_range& e) {
84852       {
84853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84854       };
84855     } catch (std::exception& e) {
84856       {
84857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84858       };
84859     } catch (Dali::DaliException e) {
84860       {
84861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84866       };
84867     }
84868   }
84869
84870   jresult = (void *)result;
84871   return jresult;
84872 }
84873
84874
84875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84876   void * jresult ;
84877   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84878   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84879   Dali::Toolkit::PageTurnView *result = 0 ;
84880
84881   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84882   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84883   if (!arg2) {
84884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84885     return 0;
84886   }
84887   {
84888     try {
84889       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84890     } catch (std::out_of_range& e) {
84891       {
84892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84893       };
84894     } catch (std::exception& e) {
84895       {
84896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84897       };
84898     } catch (Dali::DaliException e) {
84899       {
84900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84901       };
84902     } catch (...) {
84903       {
84904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84905       };
84906     }
84907   }
84908
84909   jresult = (void *)result;
84910   return jresult;
84911 }
84912
84913
84914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84915   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84916
84917   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84918   {
84919     try {
84920       delete arg1;
84921     } catch (std::out_of_range& e) {
84922       {
84923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84924       };
84925     } catch (std::exception& e) {
84926       {
84927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84928       };
84929     } catch (Dali::DaliException e) {
84930       {
84931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84932       };
84933     } catch (...) {
84934       {
84935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84936       };
84937     }
84938   }
84939
84940 }
84941
84942
84943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84944   void * jresult ;
84945   Dali::BaseHandle arg1 ;
84946   Dali::BaseHandle *argp1 ;
84947   Dali::Toolkit::PageTurnView result;
84948
84949   argp1 = (Dali::BaseHandle *)jarg1;
84950   if (!argp1) {
84951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84952     return 0;
84953   }
84954   arg1 = *argp1;
84955   {
84956     try {
84957       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84958     } catch (std::out_of_range& e) {
84959       {
84960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84961       };
84962     } catch (std::exception& e) {
84963       {
84964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84965       };
84966     } catch (Dali::DaliException e) {
84967       {
84968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84969       };
84970     } catch (...) {
84971       {
84972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84973       };
84974     }
84975   }
84976
84977   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84978   return jresult;
84979 }
84980
84981
84982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84983   void * jresult ;
84984   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84985   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84986
84987   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84988   {
84989     try {
84990       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84991     } catch (std::out_of_range& e) {
84992       {
84993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (std::exception& e) {
84996       {
84997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84998       };
84999     } catch (Dali::DaliException e) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85002       };
85003     } catch (...) {
85004       {
85005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85006       };
85007     }
85008   }
85009
85010   jresult = (void *)result;
85011   return jresult;
85012 }
85013
85014
85015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
85016   void * jresult ;
85017   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85018   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85019
85020   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85021   {
85022     try {
85023       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
85024     } catch (std::out_of_range& e) {
85025       {
85026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85027       };
85028     } catch (std::exception& e) {
85029       {
85030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85031       };
85032     } catch (Dali::DaliException e) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85035       };
85036     } catch (...) {
85037       {
85038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85039       };
85040     }
85041   }
85042
85043   jresult = (void *)result;
85044   return jresult;
85045 }
85046
85047
85048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
85049   void * jresult ;
85050   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85051   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85052
85053   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85054   {
85055     try {
85056       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (Dali::DaliException e) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85072       };
85073     }
85074   }
85075
85076   jresult = (void *)result;
85077   return jresult;
85078 }
85079
85080
85081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
85082   void * jresult ;
85083   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85084   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85085
85086   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85087   {
85088     try {
85089       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
85090     } catch (std::out_of_range& e) {
85091       {
85092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85093       };
85094     } catch (std::exception& e) {
85095       {
85096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85097       };
85098     } catch (Dali::DaliException e) {
85099       {
85100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85101       };
85102     } catch (...) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85105       };
85106     }
85107   }
85108
85109   jresult = (void *)result;
85110   return jresult;
85111 }
85112
85113
85114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
85115   void * jresult ;
85116   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85117
85118   {
85119     try {
85120       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
85121     } catch (std::out_of_range& e) {
85122       {
85123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85124       };
85125     } catch (std::exception& e) {
85126       {
85127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85128       };
85129     } catch (Dali::DaliException e) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85132       };
85133     } catch (...) {
85134       {
85135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85136       };
85137     }
85138   }
85139
85140   jresult = (void *)result;
85141   return jresult;
85142 }
85143
85144
85145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
85146   void * jresult ;
85147   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
85148   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85149
85150   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85151   if (!arg1) {
85152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85153     return 0;
85154   }
85155   {
85156     try {
85157       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
85158     } catch (std::out_of_range& e) {
85159       {
85160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85161       };
85162     } catch (std::exception& e) {
85163       {
85164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85165       };
85166     } catch (Dali::DaliException e) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85169       };
85170     } catch (...) {
85171       {
85172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85173       };
85174     }
85175   }
85176
85177   jresult = (void *)result;
85178   return jresult;
85179 }
85180
85181
85182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85183   void * jresult ;
85184   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85185   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85186   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85187
85188   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85189   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85190   if (!arg2) {
85191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85192     return 0;
85193   }
85194   {
85195     try {
85196       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85197     } catch (std::out_of_range& e) {
85198       {
85199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85200       };
85201     } catch (std::exception& e) {
85202       {
85203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (Dali::DaliException e) {
85206       {
85207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85208       };
85209     } catch (...) {
85210       {
85211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85212       };
85213     }
85214   }
85215
85216   jresult = (void *)result;
85217   return jresult;
85218 }
85219
85220
85221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85222   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85223
85224   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85225   {
85226     try {
85227       delete arg1;
85228     } catch (std::out_of_range& e) {
85229       {
85230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85231       };
85232     } catch (std::exception& e) {
85233       {
85234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85235       };
85236     } catch (Dali::DaliException e) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85239       };
85240     } catch (...) {
85241       {
85242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85243       };
85244     }
85245   }
85246
85247 }
85248
85249
85250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85251   void * jresult ;
85252   Dali::Toolkit::PageFactory *arg1 = 0 ;
85253   Dali::Vector2 *arg2 = 0 ;
85254   Dali::Toolkit::PageTurnLandscapeView result;
85255
85256   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85257   if (!arg1) {
85258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85259     return 0;
85260   }
85261   arg2 = (Dali::Vector2 *)jarg2;
85262   if (!arg2) {
85263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85264     return 0;
85265   }
85266   {
85267     try {
85268       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85276       };
85277     } catch (Dali::DaliException e) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85280       };
85281     } catch (...) {
85282       {
85283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85284       };
85285     }
85286   }
85287
85288   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85289   return jresult;
85290 }
85291
85292
85293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85294   void * jresult ;
85295   Dali::BaseHandle arg1 ;
85296   Dali::BaseHandle *argp1 ;
85297   Dali::Toolkit::PageTurnLandscapeView result;
85298
85299   argp1 = (Dali::BaseHandle *)jarg1;
85300   if (!argp1) {
85301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85302     return 0;
85303   }
85304   arg1 = *argp1;
85305   {
85306     try {
85307       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85308     } catch (std::out_of_range& e) {
85309       {
85310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85311       };
85312     } catch (std::exception& e) {
85313       {
85314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85315       };
85316     } catch (Dali::DaliException e) {
85317       {
85318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85319       };
85320     } catch (...) {
85321       {
85322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85323       };
85324     }
85325   }
85326
85327   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85328   return jresult;
85329 }
85330
85331
85332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85333   void * jresult ;
85334   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85335
85336   {
85337     try {
85338       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85339     } catch (std::out_of_range& e) {
85340       {
85341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85342       };
85343     } catch (std::exception& e) {
85344       {
85345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85346       };
85347     } catch (Dali::DaliException e) {
85348       {
85349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85350       };
85351     } catch (...) {
85352       {
85353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85354       };
85355     }
85356   }
85357
85358   jresult = (void *)result;
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85364   void * jresult ;
85365   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85366   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85367
85368   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85369   if (!arg1) {
85370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85371     return 0;
85372   }
85373   {
85374     try {
85375       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85376     } catch (std::out_of_range& e) {
85377       {
85378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (std::exception& e) {
85381       {
85382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85383       };
85384     } catch (Dali::DaliException e) {
85385       {
85386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85387       };
85388     } catch (...) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85391       };
85392     }
85393   }
85394
85395   jresult = (void *)result;
85396   return jresult;
85397 }
85398
85399
85400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85401   void * jresult ;
85402   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85403   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85404   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85405
85406   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85407   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85408   if (!arg2) {
85409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85410     return 0;
85411   }
85412   {
85413     try {
85414       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85415     } catch (std::out_of_range& e) {
85416       {
85417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85418       };
85419     } catch (std::exception& e) {
85420       {
85421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (Dali::DaliException e) {
85424       {
85425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85426       };
85427     } catch (...) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85430       };
85431     }
85432   }
85433
85434   jresult = (void *)result;
85435   return jresult;
85436 }
85437
85438
85439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85440   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85441
85442   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85443   {
85444     try {
85445       delete arg1;
85446     } catch (std::out_of_range& e) {
85447       {
85448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85449       };
85450     } catch (std::exception& e) {
85451       {
85452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85453       };
85454     } catch (Dali::DaliException e) {
85455       {
85456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85457       };
85458     } catch (...) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85461       };
85462     }
85463   }
85464
85465 }
85466
85467
85468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85469   void * jresult ;
85470   Dali::Toolkit::PageFactory *arg1 = 0 ;
85471   Dali::Vector2 *arg2 = 0 ;
85472   Dali::Toolkit::PageTurnPortraitView result;
85473
85474   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85475   if (!arg1) {
85476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85477     return 0;
85478   }
85479   arg2 = (Dali::Vector2 *)jarg2;
85480   if (!arg2) {
85481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85482     return 0;
85483   }
85484   {
85485     try {
85486       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (Dali::DaliException e) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505
85506   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85507   return jresult;
85508 }
85509
85510
85511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85512   void * jresult ;
85513   Dali::BaseHandle arg1 ;
85514   Dali::BaseHandle *argp1 ;
85515   Dali::Toolkit::PageTurnPortraitView result;
85516
85517   argp1 = (Dali::BaseHandle *)jarg1;
85518   if (!argp1) {
85519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85520     return 0;
85521   }
85522   arg1 = *argp1;
85523   {
85524     try {
85525       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85526     } catch (std::out_of_range& e) {
85527       {
85528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85529       };
85530     } catch (std::exception& e) {
85531       {
85532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85533       };
85534     } catch (Dali::DaliException e) {
85535       {
85536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85537       };
85538     } catch (...) {
85539       {
85540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85541       };
85542     }
85543   }
85544
85545   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85546   return jresult;
85547 }
85548
85549
85550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85551   int jresult ;
85552   int result;
85553
85554   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85555   jresult = (int)result;
85556   return jresult;
85557 }
85558
85559
85560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85561   int jresult ;
85562   int result;
85563
85564   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85565   jresult = (int)result;
85566   return jresult;
85567 }
85568
85569
85570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85571   int jresult ;
85572   int result;
85573
85574   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85575   jresult = (int)result;
85576   return jresult;
85577 }
85578
85579
85580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85581   void * jresult ;
85582   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85583
85584   {
85585     try {
85586       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85587     } catch (std::out_of_range& e) {
85588       {
85589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85590       };
85591     } catch (std::exception& e) {
85592       {
85593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85594       };
85595     } catch (Dali::DaliException e) {
85596       {
85597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85598       };
85599     } catch (...) {
85600       {
85601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85602       };
85603     }
85604   }
85605
85606   jresult = (void *)result;
85607   return jresult;
85608 }
85609
85610
85611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85612   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85613
85614   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85615   {
85616     try {
85617       delete arg1;
85618     } catch (std::out_of_range& e) {
85619       {
85620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85621       };
85622     } catch (std::exception& e) {
85623       {
85624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85625       };
85626     } catch (Dali::DaliException e) {
85627       {
85628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85629       };
85630     } catch (...) {
85631       {
85632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85633       };
85634     }
85635   }
85636
85637 }
85638
85639
85640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85641   void * jresult ;
85642   Dali::Toolkit::ToggleButton *result = 0 ;
85643
85644   {
85645     try {
85646       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85647     } catch (std::out_of_range& e) {
85648       {
85649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85650       };
85651     } catch (std::exception& e) {
85652       {
85653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85654       };
85655     } catch (Dali::DaliException e) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85658       };
85659     } catch (...) {
85660       {
85661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85662       };
85663     }
85664   }
85665
85666   jresult = (void *)result;
85667   return jresult;
85668 }
85669
85670
85671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85672   void * jresult ;
85673   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85674   Dali::Toolkit::ToggleButton *result = 0 ;
85675
85676   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85677   if (!arg1) {
85678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85679     return 0;
85680   }
85681   {
85682     try {
85683       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85684     } catch (std::out_of_range& e) {
85685       {
85686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85687       };
85688     } catch (std::exception& e) {
85689       {
85690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85691       };
85692     } catch (Dali::DaliException e) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85695       };
85696     } catch (...) {
85697       {
85698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85699       };
85700     }
85701   }
85702
85703   jresult = (void *)result;
85704   return jresult;
85705 }
85706
85707
85708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85709   void * jresult ;
85710   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85711   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85712   Dali::Toolkit::ToggleButton *result = 0 ;
85713
85714   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85715   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85716   if (!arg2) {
85717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85718     return 0;
85719   }
85720   {
85721     try {
85722       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85738       };
85739     }
85740   }
85741
85742   jresult = (void *)result;
85743   return jresult;
85744 }
85745
85746
85747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85748   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85749
85750   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85751   {
85752     try {
85753       delete arg1;
85754     } catch (std::out_of_range& e) {
85755       {
85756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85757       };
85758     } catch (std::exception& e) {
85759       {
85760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85761       };
85762     } catch (Dali::DaliException e) {
85763       {
85764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85765       };
85766     } catch (...) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85769       };
85770     }
85771   }
85772
85773 }
85774
85775
85776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85777   void * jresult ;
85778   Dali::Toolkit::ToggleButton result;
85779
85780   {
85781     try {
85782       result = Dali::Toolkit::ToggleButton::New();
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85790       };
85791     } catch (Dali::DaliException e) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85794       };
85795     } catch (...) {
85796       {
85797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85798       };
85799     }
85800   }
85801
85802   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85808   void * jresult ;
85809   Dali::BaseHandle arg1 ;
85810   Dali::BaseHandle *argp1 ;
85811   Dali::Toolkit::ToggleButton result;
85812
85813   argp1 = (Dali::BaseHandle *)jarg1;
85814   if (!argp1) {
85815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85816     return 0;
85817   }
85818   arg1 = *argp1;
85819   {
85820     try {
85821       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (Dali::DaliException e) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85837       };
85838     }
85839   }
85840
85841   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85847   void * jresult ;
85848   Dali::Toolkit::Visual::Base *result = 0 ;
85849
85850   {
85851     try {
85852       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85853     } catch (std::out_of_range& e) {
85854       {
85855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85856       };
85857     } catch (std::exception& e) {
85858       {
85859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (Dali::DaliException e) {
85862       {
85863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85864       };
85865     } catch (...) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85868       };
85869     }
85870   }
85871
85872   jresult = (void *)result;
85873   return jresult;
85874 }
85875
85876
85877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85878   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85879
85880   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85881   {
85882     try {
85883       delete arg1;
85884     } catch (std::out_of_range& e) {
85885       {
85886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85887       };
85888     } catch (std::exception& e) {
85889       {
85890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85891       };
85892     } catch (Dali::DaliException e) {
85893       {
85894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85895       };
85896     } catch (...) {
85897       {
85898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85899       };
85900     }
85901   }
85902
85903 }
85904
85905
85906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85907   void * jresult ;
85908   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85909   Dali::Toolkit::Visual::Base *result = 0 ;
85910
85911   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85912   if (!arg1) {
85913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85914     return 0;
85915   }
85916   {
85917     try {
85918       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85919     } catch (std::out_of_range& e) {
85920       {
85921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85922       };
85923     } catch (std::exception& e) {
85924       {
85925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (Dali::DaliException e) {
85928       {
85929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85930       };
85931     } catch (...) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85934       };
85935     }
85936   }
85937
85938   jresult = (void *)result;
85939   return jresult;
85940 }
85941
85942
85943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85944   void * jresult ;
85945   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85946   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85947   Dali::Toolkit::Visual::Base *result = 0 ;
85948
85949   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85950   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85951   if (!arg2) {
85952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85953     return 0;
85954   }
85955   {
85956     try {
85957       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85958     } catch (std::out_of_range& e) {
85959       {
85960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (std::exception& e) {
85963       {
85964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85965       };
85966     } catch (Dali::DaliException e) {
85967       {
85968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85969       };
85970     } catch (...) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85973       };
85974     }
85975   }
85976
85977   jresult = (void *)result;
85978   return jresult;
85979 }
85980
85981
85982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85983   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85984   std::string *arg2 = 0 ;
85985
85986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85987   if (!jarg2) {
85988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85989     return ;
85990   }
85991   std::string arg2_str(jarg2);
85992   arg2 = &arg2_str;
85993   {
85994     try {
85995       (arg1)->SetName((std::string const &)*arg2);
85996     } catch (std::out_of_range& e) {
85997       {
85998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85999       };
86000     } catch (std::exception& e) {
86001       {
86002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86003       };
86004     } catch (Dali::DaliException e) {
86005       {
86006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86007       };
86008     } catch (...) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86011       };
86012     }
86013   }
86014
86015
86016   //argout typemap for const std::string&
86017
86018 }
86019
86020
86021 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
86022   char * jresult ;
86023   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86024   std::string *result = 0 ;
86025
86026   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86027   {
86028     try {
86029       result = (std::string *) &(arg1)->GetName();
86030     } catch (std::out_of_range& e) {
86031       {
86032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (std::exception& e) {
86035       {
86036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (Dali::DaliException e) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048
86049   jresult = SWIG_csharp_string_callback(result->c_str());
86050   return jresult;
86051 }
86052
86053
86054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
86055   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86056   Dali::Property::Map *arg2 = 0 ;
86057   Dali::Size arg3 ;
86058   Dali::Size *argp3 ;
86059
86060   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86061   arg2 = (Dali::Property::Map *)jarg2;
86062   if (!arg2) {
86063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86064     return ;
86065   }
86066   argp3 = (Dali::Size *)jarg3;
86067   if (!argp3) {
86068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
86069     return ;
86070   }
86071   arg3 = *argp3;
86072   {
86073     try {
86074       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
86075     } catch (std::out_of_range& e) {
86076       {
86077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86078       };
86079     } catch (std::exception& e) {
86080       {
86081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86082       };
86083     } catch (Dali::DaliException e) {
86084       {
86085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86086       };
86087     } catch (...) {
86088       {
86089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86090       };
86091     }
86092   }
86093
86094 }
86095
86096
86097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
86098   float jresult ;
86099   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86100   float arg2 ;
86101   float result;
86102
86103   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86104   arg2 = (float)jarg2;
86105   {
86106     try {
86107       result = (float)(arg1)->GetHeightForWidth(arg2);
86108     } catch (std::out_of_range& e) {
86109       {
86110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86111       };
86112     } catch (std::exception& e) {
86113       {
86114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86115       };
86116     } catch (Dali::DaliException e) {
86117       {
86118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86119       };
86120     } catch (...) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86123       };
86124     }
86125   }
86126
86127   jresult = result;
86128   return jresult;
86129 }
86130
86131
86132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
86133   float jresult ;
86134   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86135   float arg2 ;
86136   float result;
86137
86138   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86139   arg2 = (float)jarg2;
86140   {
86141     try {
86142       result = (float)(arg1)->GetWidthForHeight(arg2);
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86150       };
86151     } catch (Dali::DaliException e) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86154       };
86155     } catch (...) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86158       };
86159     }
86160   }
86161
86162   jresult = result;
86163   return jresult;
86164 }
86165
86166
86167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
86168   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86169   Dali::Vector2 *arg2 = 0 ;
86170
86171   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86172   arg2 = (Dali::Vector2 *)jarg2;
86173   if (!arg2) {
86174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
86175     return ;
86176   }
86177   {
86178     try {
86179       (arg1)->GetNaturalSize(*arg2);
86180     } catch (std::out_of_range& e) {
86181       {
86182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86183       };
86184     } catch (std::exception& e) {
86185       {
86186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86187       };
86188     } catch (Dali::DaliException e) {
86189       {
86190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86191       };
86192     } catch (...) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86195       };
86196     }
86197   }
86198
86199 }
86200
86201
86202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86203   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86204   float arg2 ;
86205
86206   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86207   arg2 = (int)jarg2;
86208   {
86209     try {
86210       (arg1)->SetDepthIndex(arg2);
86211     } catch (std::out_of_range& e) {
86212       {
86213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86214       };
86215     } catch (std::exception& e) {
86216       {
86217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86218       };
86219     } catch (Dali::DaliException e) {
86220       {
86221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86222       };
86223     } catch (...) {
86224       {
86225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86226       };
86227     }
86228   }
86229
86230 }
86231
86232
86233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86234   int jresult ;
86235   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86236   int result;
86237
86238   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86239   {
86240     try {
86241       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86242     } catch (std::out_of_range& e) {
86243       {
86244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86245       };
86246     } catch (std::exception& e) {
86247       {
86248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86249       };
86250     } catch (Dali::DaliException e) {
86251       {
86252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86253       };
86254     } catch (...) {
86255       {
86256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86257       };
86258     }
86259   }
86260
86261   jresult = result;
86262   return jresult;
86263 }
86264
86265
86266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86267   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86268   Dali::Property::Map *arg2 = 0 ;
86269
86270   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86271   arg2 = (Dali::Property::Map *)jarg2;
86272   if (!arg2) {
86273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86274     return ;
86275   }
86276   {
86277     try {
86278       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86279     } catch (std::out_of_range& e) {
86280       {
86281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86282       };
86283     } catch (std::exception& e) {
86284       {
86285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86286       };
86287     } catch (Dali::DaliException e) {
86288       {
86289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86294       };
86295     }
86296   }
86297
86298 }
86299
86300
86301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86302   void * jresult ;
86303   Dali::Toolkit::VisualFactory result;
86304
86305   {
86306     try {
86307       result = Dali::Toolkit::VisualFactory::Get();
86308     } catch (std::out_of_range& e) {
86309       {
86310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86311       };
86312     } catch (std::exception& e) {
86313       {
86314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (Dali::DaliException e) {
86317       {
86318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86319       };
86320     } catch (...) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86323       };
86324     }
86325   }
86326
86327   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86328   return jresult;
86329 }
86330
86331
86332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86333   void * jresult ;
86334   Dali::Toolkit::VisualFactory *result = 0 ;
86335
86336   {
86337     try {
86338       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86339     } catch (std::out_of_range& e) {
86340       {
86341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86342       };
86343     } catch (std::exception& e) {
86344       {
86345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86346       };
86347     } catch (Dali::DaliException e) {
86348       {
86349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86350       };
86351     } catch (...) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86354       };
86355     }
86356   }
86357
86358   jresult = (void *)result;
86359   return jresult;
86360 }
86361
86362
86363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86364   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86365
86366   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86367   {
86368     try {
86369       delete arg1;
86370     } catch (std::out_of_range& e) {
86371       {
86372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86373       };
86374     } catch (std::exception& e) {
86375       {
86376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86377       };
86378     } catch (Dali::DaliException e) {
86379       {
86380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86381       };
86382     } catch (...) {
86383       {
86384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86385       };
86386     }
86387   }
86388
86389 }
86390
86391
86392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86393   void * jresult ;
86394   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86395   Dali::Toolkit::VisualFactory *result = 0 ;
86396
86397   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86398   if (!arg1) {
86399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86400     return 0;
86401   }
86402   {
86403     try {
86404       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86405     } catch (std::out_of_range& e) {
86406       {
86407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86408       };
86409     } catch (std::exception& e) {
86410       {
86411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86412       };
86413     } catch (Dali::DaliException e) {
86414       {
86415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86416       };
86417     } catch (...) {
86418       {
86419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86420       };
86421     }
86422   }
86423
86424   jresult = (void *)result;
86425   return jresult;
86426 }
86427
86428
86429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86430   void * jresult ;
86431   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86432   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86433   Dali::Toolkit::VisualFactory *result = 0 ;
86434
86435   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86436   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86437   if (!arg2) {
86438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86439     return 0;
86440   }
86441   {
86442     try {
86443       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86444     } catch (std::out_of_range& e) {
86445       {
86446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86447       };
86448     } catch (std::exception& e) {
86449       {
86450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86451       };
86452     } catch (Dali::DaliException e) {
86453       {
86454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86455       };
86456     } catch (...) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86459       };
86460     }
86461   }
86462
86463   jresult = (void *)result;
86464   return jresult;
86465 }
86466
86467
86468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86469   void * jresult ;
86470   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86471   Dali::Property::Map *arg2 = 0 ;
86472   Dali::Toolkit::Visual::Base result;
86473
86474   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86475   arg2 = (Dali::Property::Map *)jarg2;
86476   if (!arg2) {
86477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86478     return 0;
86479   }
86480   {
86481     try {
86482       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86483     } catch (std::out_of_range& e) {
86484       {
86485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86486       };
86487     } catch (std::exception& e) {
86488       {
86489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (Dali::DaliException e) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86498       };
86499     }
86500   }
86501
86502   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86503   return jresult;
86504 }
86505
86506
86507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86508   void * jresult ;
86509   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86510   std::string *arg2 = 0 ;
86511   Dali::ImageDimensions arg3 ;
86512   Dali::ImageDimensions *argp3 ;
86513   Dali::Toolkit::Visual::Base result;
86514
86515   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86516   if (!jarg2) {
86517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86518     return 0;
86519   }
86520   std::string arg2_str(jarg2);
86521   arg2 = &arg2_str;
86522   argp3 = (Dali::ImageDimensions *)jarg3;
86523   if (!argp3) {
86524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86525     return 0;
86526   }
86527   arg3 = *argp3;
86528   {
86529     try {
86530       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86531     } catch (std::out_of_range& e) {
86532       {
86533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86534       };
86535     } catch (std::exception& e) {
86536       {
86537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86538       };
86539     } catch (Dali::DaliException e) {
86540       {
86541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86542       };
86543     } catch (...) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86546       };
86547     }
86548   }
86549
86550   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86551
86552   //argout typemap for const std::string&
86553
86554   return jresult;
86555 }
86556
86557
86558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86559   void * jresult ;
86560   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86561
86562   {
86563     try {
86564       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86565     } catch (std::out_of_range& e) {
86566       {
86567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86568       };
86569     } catch (std::exception& e) {
86570       {
86571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86572       };
86573     } catch (Dali::DaliException e) {
86574       {
86575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86576       };
86577     } catch (...) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86580       };
86581     }
86582   }
86583
86584   jresult = (void *)result;
86585   return jresult;
86586 }
86587
86588
86589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86590   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86591
86592   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86593   {
86594     try {
86595       delete arg1;
86596     } catch (std::out_of_range& e) {
86597       {
86598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86599       };
86600     } catch (std::exception& e) {
86601       {
86602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86603       };
86604     } catch (Dali::DaliException e) {
86605       {
86606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86607       };
86608     } catch (...) {
86609       {
86610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86611       };
86612     }
86613   }
86614
86615 }
86616
86617
86618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86619   void * jresult ;
86620   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86621   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86622
86623   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86624   if (!arg1) {
86625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86626     return 0;
86627   }
86628   {
86629     try {
86630       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86631     } catch (std::out_of_range& e) {
86632       {
86633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86634       };
86635     } catch (std::exception& e) {
86636       {
86637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86638       };
86639     } catch (Dali::DaliException e) {
86640       {
86641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86642       };
86643     } catch (...) {
86644       {
86645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86646       };
86647     }
86648   }
86649
86650   jresult = (void *)result;
86651   return jresult;
86652 }
86653
86654
86655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86656   void * jresult ;
86657   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86658   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86659   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86660
86661   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86662   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86663   if (!arg2) {
86664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86665     return 0;
86666   }
86667   {
86668     try {
86669       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86670     } catch (std::out_of_range& e) {
86671       {
86672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (std::exception& e) {
86675       {
86676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86677       };
86678     } catch (Dali::DaliException e) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86681       };
86682     } catch (...) {
86683       {
86684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86685       };
86686     }
86687   }
86688
86689   jresult = (void *)result;
86690   return jresult;
86691 }
86692
86693
86694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86695   void * jresult ;
86696   Dali::Toolkit::AsyncImageLoader result;
86697
86698   {
86699     try {
86700       result = Dali::Toolkit::AsyncImageLoader::New();
86701     } catch (std::out_of_range& e) {
86702       {
86703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86704       };
86705     } catch (std::exception& e) {
86706       {
86707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86708       };
86709     } catch (Dali::DaliException e) {
86710       {
86711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86712       };
86713     } catch (...) {
86714       {
86715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86716       };
86717     }
86718   }
86719
86720   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86721   return jresult;
86722 }
86723
86724
86725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86726   void * jresult ;
86727   Dali::BaseHandle arg1 ;
86728   Dali::BaseHandle *argp1 ;
86729   Dali::Toolkit::AsyncImageLoader result;
86730
86731   argp1 = (Dali::BaseHandle *)jarg1;
86732   if (!argp1) {
86733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86734     return 0;
86735   }
86736   arg1 = *argp1;
86737   {
86738     try {
86739       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
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 (Dali::DaliException e) {
86749       {
86750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86751       };
86752     } catch (...) {
86753       {
86754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86755       };
86756     }
86757   }
86758
86759   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86760   return jresult;
86761 }
86762
86763
86764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86765   unsigned int jresult ;
86766   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86767   std::string *arg2 = 0 ;
86768   uint32_t result;
86769
86770   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86771   if (!jarg2) {
86772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86773     return 0;
86774   }
86775   std::string arg2_str(jarg2);
86776   arg2 = &arg2_str;
86777   {
86778     try {
86779       result = (arg1)->Load((std::string const &)*arg2);
86780     } catch (std::out_of_range& e) {
86781       {
86782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86783       };
86784     } catch (std::exception& e) {
86785       {
86786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86787       };
86788     } catch (Dali::DaliException e) {
86789       {
86790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86791       };
86792     } catch (...) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86795       };
86796     }
86797   }
86798
86799   jresult = result;
86800
86801   //argout typemap for const std::string&
86802
86803   return jresult;
86804 }
86805
86806
86807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86808   unsigned int jresult ;
86809   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86810   std::string *arg2 = 0 ;
86811   Dali::ImageDimensions arg3 ;
86812   Dali::ImageDimensions *argp3 ;
86813   uint32_t result;
86814
86815   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86816   if (!jarg2) {
86817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86818     return 0;
86819   }
86820   std::string arg2_str(jarg2);
86821   arg2 = &arg2_str;
86822   argp3 = (Dali::ImageDimensions *)jarg3;
86823   if (!argp3) {
86824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86825     return 0;
86826   }
86827   arg3 = *argp3;
86828   {
86829     try {
86830       result = (arg1)->Load((std::string const &)*arg2,arg3);
86831     } catch (std::out_of_range& e) {
86832       {
86833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86834       };
86835     } catch (std::exception& e) {
86836       {
86837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86838       };
86839     } catch (Dali::DaliException e) {
86840       {
86841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86842       };
86843     } catch (...) {
86844       {
86845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86846       };
86847     }
86848   }
86849
86850   jresult = result;
86851
86852   //argout typemap for const std::string&
86853
86854   return jresult;
86855 }
86856
86857
86858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86859   unsigned int jresult ;
86860   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86861   std::string *arg2 = 0 ;
86862   Dali::ImageDimensions arg3 ;
86863   Dali::FittingMode::Type arg4 ;
86864   Dali::SamplingMode::Type arg5 ;
86865   bool arg6 ;
86866   Dali::ImageDimensions *argp3 ;
86867   uint32_t result;
86868
86869   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86870   if (!jarg2) {
86871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86872     return 0;
86873   }
86874   std::string arg2_str(jarg2);
86875   arg2 = &arg2_str;
86876   argp3 = (Dali::ImageDimensions *)jarg3;
86877   if (!argp3) {
86878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86879     return 0;
86880   }
86881   arg3 = *argp3;
86882   arg4 = (Dali::FittingMode::Type)jarg4;
86883   arg5 = (Dali::SamplingMode::Type)jarg5;
86884   arg6 = jarg6 ? true : false;
86885   {
86886     try {
86887       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86888     } catch (std::out_of_range& e) {
86889       {
86890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86891       };
86892     } catch (std::exception& e) {
86893       {
86894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86895       };
86896     } catch (Dali::DaliException e) {
86897       {
86898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86899       };
86900     } catch (...) {
86901       {
86902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86903       };
86904     }
86905   }
86906
86907   jresult = result;
86908
86909   //argout typemap for const std::string&
86910
86911   return jresult;
86912 }
86913
86914
86915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86916   unsigned int jresult ;
86917   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86918   uint32_t arg2 ;
86919   bool result;
86920
86921   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86922   arg2 = (uint32_t)jarg2;
86923   {
86924     try {
86925       result = (bool)(arg1)->Cancel(arg2);
86926     } catch (std::out_of_range& e) {
86927       {
86928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86929       };
86930     } catch (std::exception& e) {
86931       {
86932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86933       };
86934     } catch (Dali::DaliException e) {
86935       {
86936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86937       };
86938     } catch (...) {
86939       {
86940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86941       };
86942     }
86943   }
86944
86945   jresult = result;
86946   return jresult;
86947 }
86948
86949
86950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86951   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86952
86953   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86954   {
86955     try {
86956       (arg1)->CancelAll();
86957     } catch (std::out_of_range& e) {
86958       {
86959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86960       };
86961     } catch (std::exception& e) {
86962       {
86963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86964       };
86965     } catch (Dali::DaliException e) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86968       };
86969     } catch (...) {
86970       {
86971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86972       };
86973     }
86974   }
86975
86976 }
86977
86978
86979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86980   void * jresult ;
86981   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86982   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86983
86984   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86985   {
86986     try {
86987       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86988     } catch (std::out_of_range& e) {
86989       {
86990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86991       };
86992     } catch (std::exception& e) {
86993       {
86994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86995       };
86996     } catch (Dali::DaliException e) {
86997       {
86998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86999       };
87000     } catch (...) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87003       };
87004     }
87005   }
87006
87007   jresult = (void *)result;
87008   return jresult;
87009 }
87010
87011
87012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
87013   void * jresult ;
87014   std::string *arg1 = 0 ;
87015   Dali::PixelData result;
87016
87017   if (!jarg1) {
87018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87019     return 0;
87020   }
87021   std::string arg1_str(jarg1);
87022   arg1 = &arg1_str;
87023   {
87024     try {
87025       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
87026     } catch (std::out_of_range& e) {
87027       {
87028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (std::exception& e) {
87031       {
87032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87033       };
87034     } catch (Dali::DaliException e) {
87035       {
87036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87037       };
87038     } catch (...) {
87039       {
87040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87041       };
87042     }
87043   }
87044
87045   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87046
87047   //argout typemap for const std::string&
87048
87049   return jresult;
87050 }
87051
87052
87053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
87054   void * jresult ;
87055   std::string *arg1 = 0 ;
87056   Dali::ImageDimensions arg2 ;
87057   Dali::ImageDimensions *argp2 ;
87058   Dali::PixelData result;
87059
87060   if (!jarg1) {
87061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87062     return 0;
87063   }
87064   std::string arg1_str(jarg1);
87065   arg1 = &arg1_str;
87066   argp2 = (Dali::ImageDimensions *)jarg2;
87067   if (!argp2) {
87068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87069     return 0;
87070   }
87071   arg2 = *argp2;
87072   {
87073     try {
87074       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
87075     } catch (std::out_of_range& e) {
87076       {
87077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87078       };
87079     } catch (std::exception& e) {
87080       {
87081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87082       };
87083     } catch (Dali::DaliException e) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87086       };
87087     } catch (...) {
87088       {
87089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87090       };
87091     }
87092   }
87093
87094   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87095
87096   //argout typemap for const std::string&
87097
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
87103   void * jresult ;
87104   std::string *arg1 = 0 ;
87105   Dali::ImageDimensions arg2 ;
87106   Dali::FittingMode::Type arg3 ;
87107   Dali::SamplingMode::Type arg4 ;
87108   bool arg5 ;
87109   Dali::ImageDimensions *argp2 ;
87110   Dali::PixelData result;
87111
87112   if (!jarg1) {
87113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87114     return 0;
87115   }
87116   std::string arg1_str(jarg1);
87117   arg1 = &arg1_str;
87118   argp2 = (Dali::ImageDimensions *)jarg2;
87119   if (!argp2) {
87120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87121     return 0;
87122   }
87123   arg2 = *argp2;
87124   arg3 = (Dali::FittingMode::Type)jarg3;
87125   arg4 = (Dali::SamplingMode::Type)jarg4;
87126   arg5 = jarg5 ? true : false;
87127   {
87128     try {
87129       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
87130     } catch (std::out_of_range& e) {
87131       {
87132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87133       };
87134     } catch (std::exception& e) {
87135       {
87136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87137       };
87138     } catch (Dali::DaliException e) {
87139       {
87140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87141       };
87142     } catch (...) {
87143       {
87144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87145       };
87146     }
87147   }
87148
87149   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87150
87151   //argout typemap for const std::string&
87152
87153   return jresult;
87154 }
87155
87156
87157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
87158   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87159
87160   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87161   {
87162     try {
87163       delete arg1;
87164     } catch (std::out_of_range& e) {
87165       {
87166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87167       };
87168     } catch (std::exception& e) {
87169       {
87170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87171       };
87172     } catch (Dali::DaliException e) {
87173       {
87174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87175       };
87176     } catch (...) {
87177       {
87178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87179       };
87180     }
87181   }
87182
87183 }
87184
87185
87186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87187   void * jresult ;
87188   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87189   Dali::Actor arg2 ;
87190   Dali::Actor arg3 ;
87191   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87192   Dali::Actor *argp2 ;
87193   Dali::Actor *argp3 ;
87194   Dali::Actor result;
87195
87196   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87197   argp2 = (Dali::Actor *)jarg2;
87198   if (!argp2) {
87199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87200     return 0;
87201   }
87202   arg2 = *argp2;
87203   argp3 = (Dali::Actor *)jarg3;
87204   if (!argp3) {
87205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87206     return 0;
87207   }
87208   arg3 = *argp3;
87209   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87210   {
87211     try {
87212       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87213     } catch (std::out_of_range& e) {
87214       {
87215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87216       };
87217     } catch (std::exception& e) {
87218       {
87219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87220       };
87221     } catch (Dali::DaliException e) {
87222       {
87223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87224       };
87225     } catch (...) {
87226       {
87227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87228       };
87229     }
87230   }
87231
87232   jresult = new Dali::Actor((const Dali::Actor &)result);
87233   return jresult;
87234 }
87235
87236
87237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87238   void * jresult ;
87239   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87240
87241   {
87242     try {
87243       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87244     } catch (std::out_of_range& e) {
87245       {
87246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87247       };
87248     } catch (std::exception& e) {
87249       {
87250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87251       };
87252     } catch (Dali::DaliException e) {
87253       {
87254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87255       };
87256     } catch (...) {
87257       {
87258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87259       };
87260     }
87261   }
87262
87263   jresult = (void *)result;
87264   return jresult;
87265 }
87266
87267
87268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87269   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87270   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87271   if (director) {
87272     director->swig_connect_director(callback0);
87273   }
87274 }
87275
87276
87277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87278   void * jresult ;
87279   Dali::FrameCallbackInterface *result = 0 ;
87280
87281   {
87282     try {
87283       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87284     } catch (std::out_of_range& e) {
87285       {
87286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87287       };
87288     } catch (std::exception& e) {
87289       {
87290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87291       };
87292     } catch (Dali::DaliException e) {
87293       {
87294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87295       };
87296     } catch (...) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87299       };
87300     }
87301   }
87302
87303   jresult = (void *)result;
87304   return jresult;
87305 }
87306
87307 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87308   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87309   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87310   return proxy->GetPosition(id, *vector3);
87311 }
87312
87313 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87314   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87315   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87316   return proxy->SetPosition(id, *vector3);
87317 }
87318
87319 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87320   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87321   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87322   return proxy->BakePosition(id, *vector3);
87323 }
87324
87325 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87326   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87327   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87328   return proxy->GetSize(id, *vector3);
87329 }
87330
87331 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87332   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87333   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87334   return proxy->SetSize(id, *vector3);
87335 }
87336 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87337   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87338   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87339   return proxy->BakeSize(id, *vector3);
87340 }
87341
87342 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87343   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87344   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87345   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87346   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87347 }
87348
87349 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87350   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87351   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87352   return proxy->GetScale(id,* vector3);
87353 }
87354
87355 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87356   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87357   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87358   return proxy->SetScale(id, *vector3);
87359 }
87360
87361 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87362   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87363   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87364   return proxy->BakeScale(id, *vector3);
87365 }
87366
87367 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87368   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87369   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87370   return proxy->GetColor(id, *vector4);
87371 }
87372
87373 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87374   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87375   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87376   return proxy->SetColor(id, *vector4);
87377 }
87378
87379 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87380   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87381   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87382   return proxy->BakeColor(id, *vector4);
87383 }
87384
87385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87386   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87387   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87388
87389   Dali::Stage *arg1 = (Dali::Stage *) 0;
87390   Dali::Actor *arg3 = 0;
87391
87392   arg1 = (Dali::Stage *)jarg1;
87393   arg3 = (Dali::Actor *)jarg3;
87394
87395   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87396   return;
87397 }
87398
87399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87400
87401   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87402   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87403
87404   Dali::Stage *arg1 = (Dali::Stage *) 0;
87405
87406   arg1 = (Dali::Stage *)jarg1;
87407
87408   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87409   return;
87410 }
87411
87412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87413   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87414   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87415   if (director) {
87416     director->swig_connect_director(callback0);
87417   }
87418 }
87419
87420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87421   KeyboardFocusManager arg1 ;
87422   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87423   KeyboardFocusManager *argp1 ;
87424
87425   argp1 = (KeyboardFocusManager *)jarg1;
87426   if (!argp1) {
87427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87428     return ;
87429   }
87430   arg1 = *argp1;
87431   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87432   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87433   {
87434     try {
87435       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87436     } catch (std::out_of_range& e) {
87437       {
87438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87439       };
87440     } catch (std::exception& e) {
87441       {
87442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87443       };
87444     } catch (Dali::DaliException e) {
87445       {
87446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87447       };
87448     } catch (...) {
87449       {
87450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87451       };
87452     }
87453   }
87454
87455 }
87456
87457
87458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87459   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87460
87461   arg1 = (std::vector< unsigned int > *)jarg1;
87462   {
87463     try {
87464       (arg1)->clear();
87465     } catch (std::out_of_range& e) {
87466       {
87467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87468       };
87469     } catch (std::exception& e) {
87470       {
87471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87472       };
87473     } catch (Dali::DaliException e) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87476       };
87477     } catch (...) {
87478       {
87479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87480       };
87481     }
87482   }
87483
87484 }
87485
87486
87487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87488   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87489   unsigned int *arg2 = 0 ;
87490   unsigned int temp2 ;
87491
87492   arg1 = (std::vector< unsigned int > *)jarg1;
87493   temp2 = (unsigned int)jarg2;
87494   arg2 = &temp2;
87495   {
87496     try {
87497       (arg1)->push_back((unsigned int const &)*arg2);
87498     } catch (std::out_of_range& e) {
87499       {
87500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87501       };
87502     } catch (std::exception& e) {
87503       {
87504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87505       };
87506     } catch (Dali::DaliException e) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87509       };
87510     } catch (...) {
87511       {
87512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87513       };
87514     }
87515   }
87516
87517 }
87518
87519
87520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87521   unsigned long jresult ;
87522   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87523   std::vector< unsigned int >::size_type result;
87524
87525   arg1 = (std::vector< unsigned int > *)jarg1;
87526   {
87527     try {
87528       result = ((std::vector< unsigned int > const *)arg1)->size();
87529     } catch (std::out_of_range& e) {
87530       {
87531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87532       };
87533     } catch (std::exception& e) {
87534       {
87535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87536       };
87537     } catch (Dali::DaliException e) {
87538       {
87539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87540       };
87541     } catch (...) {
87542       {
87543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87544       };
87545     }
87546   }
87547
87548   jresult = (unsigned long)result;
87549   return jresult;
87550 }
87551
87552
87553 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87554   unsigned long jresult ;
87555   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87556   std::vector< unsigned int >::size_type result;
87557
87558   arg1 = (std::vector< unsigned int > *)jarg1;
87559   {
87560     try {
87561       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87562     } catch (std::out_of_range& e) {
87563       {
87564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87565       };
87566     } catch (std::exception& e) {
87567       {
87568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87569       };
87570     } catch (Dali::DaliException e) {
87571       {
87572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87577       };
87578     }
87579   }
87580
87581   jresult = (unsigned long)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87587   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87588   std::vector< unsigned int >::size_type arg2 ;
87589
87590   arg1 = (std::vector< unsigned int > *)jarg1;
87591   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87592   {
87593     try {
87594       (arg1)->reserve(arg2);
87595     } catch (std::out_of_range& e) {
87596       {
87597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87598       };
87599     } catch (std::exception& e) {
87600       {
87601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87602       };
87603     } catch (Dali::DaliException e) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87606       };
87607     } catch (...) {
87608       {
87609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87610       };
87611     }
87612   }
87613
87614 }
87615
87616
87617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87618   void * jresult ;
87619   std::vector< unsigned int > *result = 0 ;
87620
87621   {
87622     try {
87623       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87624     } catch (std::out_of_range& e) {
87625       {
87626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87627       };
87628     } catch (std::exception& e) {
87629       {
87630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87631       };
87632     } catch (Dali::DaliException e) {
87633       {
87634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87635       };
87636     } catch (...) {
87637       {
87638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87639       };
87640     }
87641   }
87642
87643   jresult = (void *)result;
87644   return jresult;
87645 }
87646
87647
87648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87649   void * jresult ;
87650   std::vector< unsigned int > *arg1 = 0 ;
87651   std::vector< unsigned int > *result = 0 ;
87652
87653   arg1 = (std::vector< unsigned int > *)jarg1;
87654   if (!arg1) {
87655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87656     return 0;
87657   }
87658   {
87659     try {
87660       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87661     } catch (std::out_of_range& e) {
87662       {
87663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87664       };
87665     } catch (std::exception& e) {
87666       {
87667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87668       };
87669     } catch (Dali::DaliException e) {
87670       {
87671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87672       };
87673     } catch (...) {
87674       {
87675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87676       };
87677     }
87678   }
87679
87680   jresult = (void *)result;
87681   return jresult;
87682 }
87683
87684
87685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87686   void * jresult ;
87687   int arg1 ;
87688   std::vector< unsigned int > *result = 0 ;
87689
87690   arg1 = (int)jarg1;
87691   {
87692     try {
87693       try {
87694         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87695       }
87696       catch(std::out_of_range &_e) {
87697         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87698         return 0;
87699       }
87700
87701     } catch (std::out_of_range& e) {
87702       {
87703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87704       };
87705     } catch (std::exception& e) {
87706       {
87707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87708       };
87709     } catch (Dali::DaliException e) {
87710       {
87711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87712       };
87713     } catch (...) {
87714       {
87715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87716       };
87717     }
87718   }
87719
87720   jresult = (void *)result;
87721   return jresult;
87722 }
87723
87724
87725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87726   unsigned int jresult ;
87727   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87728   int arg2 ;
87729   unsigned int result;
87730
87731   arg1 = (std::vector< unsigned int > *)jarg1;
87732   arg2 = (int)jarg2;
87733   {
87734     try {
87735       try {
87736         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87737       }
87738       catch(std::out_of_range &_e) {
87739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87740         return 0;
87741       }
87742
87743     } catch (std::out_of_range& e) {
87744       {
87745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87746       };
87747     } catch (std::exception& e) {
87748       {
87749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87750       };
87751     } catch (Dali::DaliException e) {
87752       {
87753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87754       };
87755     } catch (...) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87758       };
87759     }
87760   }
87761
87762   jresult = result;
87763   return jresult;
87764 }
87765
87766
87767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87768   unsigned int jresult ;
87769   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87770   int arg2 ;
87771   unsigned int *result = 0 ;
87772
87773   arg1 = (std::vector< unsigned int > *)jarg1;
87774   arg2 = (int)jarg2;
87775   {
87776     try {
87777       try {
87778         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87779       }
87780       catch(std::out_of_range &_e) {
87781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87782         return 0;
87783       }
87784
87785     } catch (std::out_of_range& e) {
87786       {
87787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87788       };
87789     } catch (std::exception& e) {
87790       {
87791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87792       };
87793     } catch (Dali::DaliException e) {
87794       {
87795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87796       };
87797     } catch (...) {
87798       {
87799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87800       };
87801     }
87802   }
87803
87804   jresult = *result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87810   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87811   int arg2 ;
87812   unsigned int *arg3 = 0 ;
87813   unsigned int temp3 ;
87814
87815   arg1 = (std::vector< unsigned int > *)jarg1;
87816   arg2 = (int)jarg2;
87817   temp3 = (unsigned int)jarg3;
87818   arg3 = &temp3;
87819   {
87820     try {
87821       try {
87822         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87823       }
87824       catch(std::out_of_range &_e) {
87825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87826         return ;
87827       }
87828
87829     } catch (std::out_of_range& e) {
87830       {
87831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87832       };
87833     } catch (std::exception& e) {
87834       {
87835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87836       };
87837     } catch (Dali::DaliException e) {
87838       {
87839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87840       };
87841     } catch (...) {
87842       {
87843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87844       };
87845     }
87846   }
87847
87848 }
87849
87850
87851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87852   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87853   std::vector< unsigned int > *arg2 = 0 ;
87854
87855   arg1 = (std::vector< unsigned int > *)jarg1;
87856   arg2 = (std::vector< unsigned int > *)jarg2;
87857   if (!arg2) {
87858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87859     return ;
87860   }
87861   {
87862     try {
87863       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87864     } catch (std::out_of_range& e) {
87865       {
87866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87867       };
87868     } catch (std::exception& e) {
87869       {
87870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87871       };
87872     } catch (Dali::DaliException e) {
87873       {
87874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87875       };
87876     } catch (...) {
87877       {
87878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87879       };
87880     }
87881   }
87882
87883 }
87884
87885
87886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87887   void * jresult ;
87888   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87889   int arg2 ;
87890   int arg3 ;
87891   std::vector< unsigned int > *result = 0 ;
87892
87893   arg1 = (std::vector< unsigned int > *)jarg1;
87894   arg2 = (int)jarg2;
87895   arg3 = (int)jarg3;
87896   {
87897     try {
87898       try {
87899         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87900       }
87901       catch(std::out_of_range &_e) {
87902         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87903         return 0;
87904       }
87905       catch(std::invalid_argument &_e) {
87906         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87907         return 0;
87908       }
87909
87910     } catch (std::out_of_range& e) {
87911       {
87912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87913       };
87914     } catch (std::exception& e) {
87915       {
87916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87917       };
87918     } catch (Dali::DaliException e) {
87919       {
87920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87921       };
87922     } catch (...) {
87923       {
87924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87925       };
87926     }
87927   }
87928
87929   jresult = (void *)result;
87930   return jresult;
87931 }
87932
87933
87934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87935   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87936   int arg2 ;
87937   unsigned int *arg3 = 0 ;
87938   unsigned int temp3 ;
87939
87940   arg1 = (std::vector< unsigned int > *)jarg1;
87941   arg2 = (int)jarg2;
87942   temp3 = (unsigned int)jarg3;
87943   arg3 = &temp3;
87944   {
87945     try {
87946       try {
87947         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87948       }
87949       catch(std::out_of_range &_e) {
87950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87951         return ;
87952       }
87953
87954     } catch (std::out_of_range& e) {
87955       {
87956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87957       };
87958     } catch (std::exception& e) {
87959       {
87960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87961       };
87962     } catch (Dali::DaliException e) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87965       };
87966     } catch (...) {
87967       {
87968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87969       };
87970     }
87971   }
87972
87973 }
87974
87975
87976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87977   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87978   int arg2 ;
87979   std::vector< unsigned int > *arg3 = 0 ;
87980
87981   arg1 = (std::vector< unsigned int > *)jarg1;
87982   arg2 = (int)jarg2;
87983   arg3 = (std::vector< unsigned int > *)jarg3;
87984   if (!arg3) {
87985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87986     return ;
87987   }
87988   {
87989     try {
87990       try {
87991         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87992       }
87993       catch(std::out_of_range &_e) {
87994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87995         return ;
87996       }
87997
87998     } catch (std::out_of_range& e) {
87999       {
88000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88001       };
88002     } catch (std::exception& e) {
88003       {
88004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88005       };
88006     } catch (Dali::DaliException e) {
88007       {
88008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88009       };
88010     } catch (...) {
88011       {
88012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88013       };
88014     }
88015   }
88016
88017 }
88018
88019
88020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
88021   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88022   int arg2 ;
88023
88024   arg1 = (std::vector< unsigned int > *)jarg1;
88025   arg2 = (int)jarg2;
88026   {
88027     try {
88028       try {
88029         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
88030       }
88031       catch(std::out_of_range &_e) {
88032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88033         return ;
88034       }
88035
88036     } catch (std::out_of_range& e) {
88037       {
88038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88039       };
88040     } catch (std::exception& e) {
88041       {
88042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88043       };
88044     } catch (Dali::DaliException e) {
88045       {
88046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88047       };
88048     } catch (...) {
88049       {
88050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88051       };
88052     }
88053   }
88054
88055 }
88056
88057
88058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88059   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88060   int arg2 ;
88061   int arg3 ;
88062
88063   arg1 = (std::vector< unsigned int > *)jarg1;
88064   arg2 = (int)jarg2;
88065   arg3 = (int)jarg3;
88066   {
88067     try {
88068       try {
88069         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
88070       }
88071       catch(std::out_of_range &_e) {
88072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88073         return ;
88074       }
88075       catch(std::invalid_argument &_e) {
88076         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88077         return ;
88078       }
88079
88080     } catch (std::out_of_range& e) {
88081       {
88082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (std::exception& e) {
88085       {
88086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88087       };
88088     } catch (Dali::DaliException e) {
88089       {
88090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88091       };
88092     } catch (...) {
88093       {
88094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88095       };
88096     }
88097   }
88098
88099 }
88100
88101
88102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
88103   void * jresult ;
88104   unsigned int *arg1 = 0 ;
88105   int arg2 ;
88106   unsigned int temp1 ;
88107   std::vector< unsigned int > *result = 0 ;
88108
88109   temp1 = (unsigned int)jarg1;
88110   arg1 = &temp1;
88111   arg2 = (int)jarg2;
88112   {
88113     try {
88114       try {
88115         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
88116       }
88117       catch(std::out_of_range &_e) {
88118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88119         return 0;
88120       }
88121
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (Dali::DaliException e) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88137       };
88138     }
88139   }
88140
88141   jresult = (void *)result;
88142   return jresult;
88143 }
88144
88145
88146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
88147   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88148
88149   arg1 = (std::vector< unsigned int > *)jarg1;
88150   {
88151     try {
88152       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
88153     } catch (std::out_of_range& e) {
88154       {
88155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88156       };
88157     } catch (std::exception& e) {
88158       {
88159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (Dali::DaliException e) {
88162       {
88163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88164       };
88165     } catch (...) {
88166       {
88167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88168       };
88169     }
88170   }
88171
88172 }
88173
88174
88175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88176   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88177   int arg2 ;
88178   int arg3 ;
88179
88180   arg1 = (std::vector< unsigned int > *)jarg1;
88181   arg2 = (int)jarg2;
88182   arg3 = (int)jarg3;
88183   {
88184     try {
88185       try {
88186         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88187       }
88188       catch(std::out_of_range &_e) {
88189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88190         return ;
88191       }
88192       catch(std::invalid_argument &_e) {
88193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88194         return ;
88195       }
88196
88197     } catch (std::out_of_range& e) {
88198       {
88199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88200       };
88201     } catch (std::exception& e) {
88202       {
88203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (Dali::DaliException e) {
88206       {
88207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88208       };
88209     } catch (...) {
88210       {
88211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88212       };
88213     }
88214   }
88215
88216 }
88217
88218
88219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88220   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88221   int arg2 ;
88222   std::vector< unsigned int > *arg3 = 0 ;
88223
88224   arg1 = (std::vector< unsigned int > *)jarg1;
88225   arg2 = (int)jarg2;
88226   arg3 = (std::vector< unsigned int > *)jarg3;
88227   if (!arg3) {
88228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88229     return ;
88230   }
88231   {
88232     try {
88233       try {
88234         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88235       }
88236       catch(std::out_of_range &_e) {
88237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88238         return ;
88239       }
88240
88241     } catch (std::out_of_range& e) {
88242       {
88243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88244       };
88245     } catch (std::exception& e) {
88246       {
88247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88248       };
88249     } catch (Dali::DaliException e) {
88250       {
88251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88252       };
88253     } catch (...) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88256       };
88257     }
88258   }
88259
88260 }
88261
88262
88263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88264   unsigned int jresult ;
88265   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88266   unsigned int *arg2 = 0 ;
88267   unsigned int temp2 ;
88268   bool result;
88269
88270   arg1 = (std::vector< unsigned int > *)jarg1;
88271   temp2 = (unsigned int)jarg2;
88272   arg2 = &temp2;
88273   {
88274     try {
88275       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88276     } catch (std::out_of_range& e) {
88277       {
88278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88279       };
88280     } catch (std::exception& e) {
88281       {
88282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88283       };
88284     } catch (Dali::DaliException e) {
88285       {
88286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88287       };
88288     } catch (...) {
88289       {
88290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88291       };
88292     }
88293   }
88294
88295   jresult = result;
88296   return jresult;
88297 }
88298
88299
88300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88301   int jresult ;
88302   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88303   unsigned int *arg2 = 0 ;
88304   unsigned int temp2 ;
88305   int result;
88306
88307   arg1 = (std::vector< unsigned int > *)jarg1;
88308   temp2 = (unsigned int)jarg2;
88309   arg2 = &temp2;
88310   {
88311     try {
88312       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88313     } catch (std::out_of_range& e) {
88314       {
88315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88316       };
88317     } catch (std::exception& e) {
88318       {
88319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88320       };
88321     } catch (Dali::DaliException e) {
88322       {
88323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88324       };
88325     } catch (...) {
88326       {
88327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88328       };
88329     }
88330   }
88331
88332   jresult = result;
88333   return jresult;
88334 }
88335
88336
88337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88338   int jresult ;
88339   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88340   unsigned int *arg2 = 0 ;
88341   unsigned int temp2 ;
88342   int result;
88343
88344   arg1 = (std::vector< unsigned int > *)jarg1;
88345   temp2 = (unsigned int)jarg2;
88346   arg2 = &temp2;
88347   {
88348     try {
88349       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88350     } catch (std::out_of_range& e) {
88351       {
88352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88353       };
88354     } catch (std::exception& e) {
88355       {
88356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88357       };
88358     } catch (Dali::DaliException e) {
88359       {
88360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88361       };
88362     } catch (...) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88365       };
88366     }
88367   }
88368
88369   jresult = result;
88370   return jresult;
88371 }
88372
88373
88374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88375   unsigned int jresult ;
88376   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88377   unsigned int *arg2 = 0 ;
88378   unsigned int temp2 ;
88379   bool result;
88380
88381   arg1 = (std::vector< unsigned int > *)jarg1;
88382   temp2 = (unsigned int)jarg2;
88383   arg2 = &temp2;
88384   {
88385     try {
88386       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88387     } catch (std::out_of_range& e) {
88388       {
88389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88390       };
88391     } catch (std::exception& e) {
88392       {
88393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88394       };
88395     } catch (Dali::DaliException e) {
88396       {
88397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88398       };
88399     } catch (...) {
88400       {
88401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88402       };
88403     }
88404   }
88405
88406   jresult = result;
88407   return jresult;
88408 }
88409
88410
88411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88412   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88413
88414   arg1 = (std::vector< unsigned int > *)jarg1;
88415   {
88416     try {
88417       delete arg1;
88418     } catch (std::out_of_range& e) {
88419       {
88420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88421       };
88422     } catch (std::exception& e) {
88423       {
88424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88425       };
88426     } catch (Dali::DaliException e) {
88427       {
88428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88429       };
88430     } catch (...) {
88431       {
88432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88433       };
88434     }
88435   }
88436
88437 }
88438
88439
88440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88441   void * jresult ;
88442   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88443
88444   {
88445     try {
88446       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88447     } catch (std::out_of_range& e) {
88448       {
88449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88450       };
88451     } catch (std::exception& e) {
88452       {
88453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88454       };
88455     } catch (Dali::DaliException e) {
88456       {
88457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88458       };
88459     } catch (...) {
88460       {
88461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88462       };
88463     }
88464   }
88465
88466   jresult = (void *)result;
88467   return jresult;
88468 }
88469
88470
88471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88472   void * jresult ;
88473   unsigned int arg1 ;
88474   Dali::Actor arg2 ;
88475   Dali::Actor *argp2 ;
88476   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88477
88478   arg1 = (unsigned int)jarg1;
88479   argp2 = (Dali::Actor *)jarg2;
88480   if (!argp2) {
88481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88482     return 0;
88483   }
88484   arg2 = *argp2;
88485   {
88486     try {
88487       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88488     } catch (std::out_of_range& e) {
88489       {
88490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88491       };
88492     } catch (std::exception& e) {
88493       {
88494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88495       };
88496     } catch (Dali::DaliException e) {
88497       {
88498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88499       };
88500     } catch (...) {
88501       {
88502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88503       };
88504     }
88505   }
88506
88507   jresult = (void *)result;
88508   return jresult;
88509 }
88510
88511
88512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88513   void * jresult ;
88514   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88515   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88516
88517   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88518   if (!arg1) {
88519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88520     return 0;
88521   }
88522   {
88523     try {
88524       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88525     } catch (std::out_of_range& e) {
88526       {
88527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88528       };
88529     } catch (std::exception& e) {
88530       {
88531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88532       };
88533     } catch (Dali::DaliException e) {
88534       {
88535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88536       };
88537     } catch (...) {
88538       {
88539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88540       };
88541     }
88542   }
88543
88544   jresult = (void *)result;
88545   return jresult;
88546 }
88547
88548
88549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88550   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88551   unsigned int arg2 ;
88552
88553   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88554   arg2 = (unsigned int)jarg2;
88555   if (arg1) (arg1)->first = arg2;
88556 }
88557
88558
88559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88560   unsigned int jresult ;
88561   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88562   unsigned int result;
88563
88564   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88565   result = (unsigned int) ((arg1)->first);
88566   jresult = result;
88567   return jresult;
88568 }
88569
88570
88571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88572   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88573   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88574
88575   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88576   arg2 = (Dali::Actor *)jarg2;
88577   if (arg1) (arg1)->second = *arg2;
88578 }
88579
88580
88581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88582   void * jresult ;
88583   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88584   Dali::Actor *result = 0 ;
88585
88586   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88587   result = (Dali::Actor *)& ((arg1)->second);
88588   jresult = (void *)result;
88589   return jresult;
88590 }
88591
88592
88593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88594   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88595
88596   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88597   {
88598     try {
88599       delete arg1;
88600     } catch (std::out_of_range& e) {
88601       {
88602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88603       };
88604     } catch (std::exception& e) {
88605       {
88606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88607       };
88608     } catch (Dali::DaliException e) {
88609       {
88610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88611       };
88612     } catch (...) {
88613       {
88614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88615       };
88616     }
88617   }
88618
88619 }
88620
88621
88622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88623   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88624
88625   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88626   {
88627     try {
88628       (arg1)->clear();
88629     } catch (std::out_of_range& e) {
88630       {
88631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88632       };
88633     } catch (std::exception& e) {
88634       {
88635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88636       };
88637     } catch (Dali::DaliException e) {
88638       {
88639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88640       };
88641     } catch (...) {
88642       {
88643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88644       };
88645     }
88646   }
88647
88648 }
88649
88650
88651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88652   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88653   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88654
88655   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88656   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88657   if (!arg2) {
88658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88659     return ;
88660   }
88661   {
88662     try {
88663       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88664     } catch (std::out_of_range& e) {
88665       {
88666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88667       };
88668     } catch (std::exception& e) {
88669       {
88670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88671       };
88672     } catch (Dali::DaliException e) {
88673       {
88674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88675       };
88676     } catch (...) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88679       };
88680     }
88681   }
88682
88683 }
88684
88685
88686 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88687   unsigned long jresult ;
88688   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88689   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88690
88691   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88692   {
88693     try {
88694       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88695     } catch (std::out_of_range& e) {
88696       {
88697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88698       };
88699     } catch (std::exception& e) {
88700       {
88701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88702       };
88703     } catch (Dali::DaliException e) {
88704       {
88705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88706       };
88707     } catch (...) {
88708       {
88709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88710       };
88711     }
88712   }
88713
88714   jresult = (unsigned long)result;
88715   return jresult;
88716 }
88717
88718
88719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88720   unsigned long jresult ;
88721   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88722   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88723
88724   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88725   {
88726     try {
88727       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88728     } catch (std::out_of_range& e) {
88729       {
88730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88731       };
88732     } catch (std::exception& e) {
88733       {
88734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88735       };
88736     } catch (Dali::DaliException e) {
88737       {
88738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88739       };
88740     } catch (...) {
88741       {
88742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88743       };
88744     }
88745   }
88746
88747   jresult = (unsigned long)result;
88748   return jresult;
88749 }
88750
88751
88752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88753   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88754   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88755
88756   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88757   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88758   {
88759     try {
88760       (arg1)->reserve(arg2);
88761     } catch (std::out_of_range& e) {
88762       {
88763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88764       };
88765     } catch (std::exception& e) {
88766       {
88767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88768       };
88769     } catch (Dali::DaliException e) {
88770       {
88771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88772       };
88773     } catch (...) {
88774       {
88775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88776       };
88777     }
88778   }
88779
88780 }
88781
88782
88783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88784   void * jresult ;
88785   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88786
88787   {
88788     try {
88789       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88790     } catch (std::out_of_range& e) {
88791       {
88792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88793       };
88794     } catch (std::exception& e) {
88795       {
88796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88797       };
88798     } catch (Dali::DaliException e) {
88799       {
88800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88801       };
88802     } catch (...) {
88803       {
88804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88805       };
88806     }
88807   }
88808
88809   jresult = (void *)result;
88810   return jresult;
88811 }
88812
88813
88814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88815   void * jresult ;
88816   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88817   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88818
88819   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88820   if (!arg1) {
88821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88822     return 0;
88823   }
88824   {
88825     try {
88826       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);
88827     } catch (std::out_of_range& e) {
88828       {
88829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88830       };
88831     } catch (std::exception& e) {
88832       {
88833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88834       };
88835     } catch (Dali::DaliException e) {
88836       {
88837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88838       };
88839     } catch (...) {
88840       {
88841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88842       };
88843     }
88844   }
88845
88846   jresult = (void *)result;
88847   return jresult;
88848 }
88849
88850
88851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88852   void * jresult ;
88853   int arg1 ;
88854   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88855
88856   arg1 = (int)jarg1;
88857   {
88858     try {
88859       try {
88860         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);
88861       }
88862       catch(std::out_of_range &_e) {
88863         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88864         return 0;
88865       }
88866
88867     } catch (std::out_of_range& e) {
88868       {
88869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88870       };
88871     } catch (std::exception& e) {
88872       {
88873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88874       };
88875     } catch (Dali::DaliException e) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88878       };
88879     } catch (...) {
88880       {
88881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88882       };
88883     }
88884   }
88885
88886   jresult = (void *)result;
88887   return jresult;
88888 }
88889
88890
88891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88892   void * jresult ;
88893   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88894   int arg2 ;
88895   std::pair< unsigned int,Dali::Actor > result;
88896
88897   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88898   arg2 = (int)jarg2;
88899   {
88900     try {
88901       try {
88902         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88903       }
88904       catch(std::out_of_range &_e) {
88905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88906         return 0;
88907       }
88908
88909     } catch (std::out_of_range& e) {
88910       {
88911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88912       };
88913     } catch (std::exception& e) {
88914       {
88915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88916       };
88917     } catch (Dali::DaliException e) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88920       };
88921     } catch (...) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88924       };
88925     }
88926   }
88927
88928   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88929   return jresult;
88930 }
88931
88932
88933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88934   void * jresult ;
88935   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88936   int arg2 ;
88937   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88938
88939   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88940   arg2 = (int)jarg2;
88941   {
88942     try {
88943       try {
88944         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88945       }
88946       catch(std::out_of_range &_e) {
88947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88948         return 0;
88949       }
88950
88951     } catch (std::out_of_range& e) {
88952       {
88953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88954       };
88955     } catch (std::exception& e) {
88956       {
88957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88958       };
88959     } catch (Dali::DaliException e) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88962       };
88963     } catch (...) {
88964       {
88965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88966       };
88967     }
88968   }
88969
88970   jresult = (void *)result;
88971   return jresult;
88972 }
88973
88974
88975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88976   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88977   int arg2 ;
88978   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88979
88980   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88981   arg2 = (int)jarg2;
88982   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88983   if (!arg3) {
88984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88985     return ;
88986   }
88987   {
88988     try {
88989       try {
88990         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);
88991       }
88992       catch(std::out_of_range &_e) {
88993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88994         return ;
88995       }
88996
88997     } catch (std::out_of_range& e) {
88998       {
88999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89000       };
89001     } catch (std::exception& e) {
89002       {
89003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89004       };
89005     } catch (Dali::DaliException e) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89008       };
89009     } catch (...) {
89010       {
89011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89012       };
89013     }
89014   }
89015
89016 }
89017
89018
89019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
89020   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89021   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
89022
89023   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89024   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
89025   if (!arg2) {
89026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89027     return ;
89028   }
89029   {
89030     try {
89031       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);
89032     } catch (std::out_of_range& e) {
89033       {
89034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89035       };
89036     } catch (std::exception& e) {
89037       {
89038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89039       };
89040     } catch (Dali::DaliException e) {
89041       {
89042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89043       };
89044     } catch (...) {
89045       {
89046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89047       };
89048     }
89049   }
89050
89051 }
89052
89053
89054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89055   void * jresult ;
89056   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89057   int arg2 ;
89058   int arg3 ;
89059   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89060
89061   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89062   arg2 = (int)jarg2;
89063   arg3 = (int)jarg3;
89064   {
89065     try {
89066       try {
89067         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);
89068       }
89069       catch(std::out_of_range &_e) {
89070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89071         return 0;
89072       }
89073       catch(std::invalid_argument &_e) {
89074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89075         return 0;
89076       }
89077
89078     } catch (std::out_of_range& e) {
89079       {
89080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89081       };
89082     } catch (std::exception& e) {
89083       {
89084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89085       };
89086     } catch (Dali::DaliException e) {
89087       {
89088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89089       };
89090     } catch (...) {
89091       {
89092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89093       };
89094     }
89095   }
89096
89097   jresult = (void *)result;
89098   return jresult;
89099 }
89100
89101
89102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89103   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89104   int arg2 ;
89105   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89106
89107   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89108   arg2 = (int)jarg2;
89109   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89110   if (!arg3) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89112     return ;
89113   }
89114   {
89115     try {
89116       try {
89117         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);
89118       }
89119       catch(std::out_of_range &_e) {
89120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89121         return ;
89122       }
89123
89124     } catch (std::out_of_range& e) {
89125       {
89126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89127       };
89128     } catch (std::exception& e) {
89129       {
89130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89131       };
89132     } catch (Dali::DaliException e) {
89133       {
89134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89135       };
89136     } catch (...) {
89137       {
89138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89139       };
89140     }
89141   }
89142
89143 }
89144
89145
89146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89147   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89148   int arg2 ;
89149   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89150
89151   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89152   arg2 = (int)jarg2;
89153   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89154   if (!arg3) {
89155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89156     return ;
89157   }
89158   {
89159     try {
89160       try {
89161         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);
89162       }
89163       catch(std::out_of_range &_e) {
89164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89165         return ;
89166       }
89167
89168     } catch (std::out_of_range& e) {
89169       {
89170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89171       };
89172     } catch (std::exception& e) {
89173       {
89174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89175       };
89176     } catch (Dali::DaliException e) {
89177       {
89178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89179       };
89180     } catch (...) {
89181       {
89182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89183       };
89184     }
89185   }
89186
89187 }
89188
89189
89190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89192   int arg2 ;
89193
89194   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89195   arg2 = (int)jarg2;
89196   {
89197     try {
89198       try {
89199         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89200       }
89201       catch(std::out_of_range &_e) {
89202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89203         return ;
89204       }
89205
89206     } catch (std::out_of_range& e) {
89207       {
89208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89209       };
89210     } catch (std::exception& e) {
89211       {
89212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89213       };
89214     } catch (Dali::DaliException e) {
89215       {
89216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89217       };
89218     } catch (...) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89221       };
89222     }
89223   }
89224
89225 }
89226
89227
89228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89229   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89230   int arg2 ;
89231   int arg3 ;
89232
89233   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89234   arg2 = (int)jarg2;
89235   arg3 = (int)jarg3;
89236   {
89237     try {
89238       try {
89239         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89240       }
89241       catch(std::out_of_range &_e) {
89242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89243         return ;
89244       }
89245       catch(std::invalid_argument &_e) {
89246         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89247         return ;
89248       }
89249
89250     } catch (std::out_of_range& e) {
89251       {
89252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (std::exception& e) {
89255       {
89256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89257       };
89258     } catch (Dali::DaliException e) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89261       };
89262     } catch (...) {
89263       {
89264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89265       };
89266     }
89267   }
89268
89269 }
89270
89271
89272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89273   void * jresult ;
89274   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89275   int arg2 ;
89276   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89277
89278   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89279   if (!arg1) {
89280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89281     return 0;
89282   }
89283   arg2 = (int)jarg2;
89284   {
89285     try {
89286       try {
89287         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);
89288       }
89289       catch(std::out_of_range &_e) {
89290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89291         return 0;
89292       }
89293
89294     } catch (std::out_of_range& e) {
89295       {
89296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89297       };
89298     } catch (std::exception& e) {
89299       {
89300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89301       };
89302     } catch (Dali::DaliException e) {
89303       {
89304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89305       };
89306     } catch (...) {
89307       {
89308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89309       };
89310     }
89311   }
89312
89313   jresult = (void *)result;
89314   return jresult;
89315 }
89316
89317
89318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89319   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89320
89321   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89322   {
89323     try {
89324       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89325     } catch (std::out_of_range& e) {
89326       {
89327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89328       };
89329     } catch (std::exception& e) {
89330       {
89331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89332       };
89333     } catch (Dali::DaliException e) {
89334       {
89335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89336       };
89337     } catch (...) {
89338       {
89339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89340       };
89341     }
89342   }
89343
89344 }
89345
89346
89347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89348   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89349   int arg2 ;
89350   int arg3 ;
89351
89352   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89353   arg2 = (int)jarg2;
89354   arg3 = (int)jarg3;
89355   {
89356     try {
89357       try {
89358         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89359       }
89360       catch(std::out_of_range &_e) {
89361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89362         return ;
89363       }
89364       catch(std::invalid_argument &_e) {
89365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89366         return ;
89367       }
89368
89369     } catch (std::out_of_range& e) {
89370       {
89371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89372       };
89373     } catch (std::exception& e) {
89374       {
89375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89376       };
89377     } catch (Dali::DaliException e) {
89378       {
89379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89380       };
89381     } catch (...) {
89382       {
89383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89384       };
89385     }
89386   }
89387
89388 }
89389
89390
89391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89392   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89393   int arg2 ;
89394   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89395
89396   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89397   arg2 = (int)jarg2;
89398   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89399   if (!arg3) {
89400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89401     return ;
89402   }
89403   {
89404     try {
89405       try {
89406         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);
89407       }
89408       catch(std::out_of_range &_e) {
89409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89410         return ;
89411       }
89412
89413     } catch (std::out_of_range& e) {
89414       {
89415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89416       };
89417     } catch (std::exception& e) {
89418       {
89419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89420       };
89421     } catch (Dali::DaliException e) {
89422       {
89423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89424       };
89425     } catch (...) {
89426       {
89427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89428       };
89429     }
89430   }
89431
89432 }
89433
89434
89435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89437
89438   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89439   {
89440     try {
89441       delete arg1;
89442     } catch (std::out_of_range& e) {
89443       {
89444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (std::exception& e) {
89447       {
89448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89449       };
89450     } catch (Dali::DaliException e) {
89451       {
89452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89453       };
89454     } catch (...) {
89455       {
89456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89457       };
89458     }
89459   }
89460
89461 }
89462
89463
89464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89465   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89466
89467   arg1 = (std::vector< Dali::Actor > *)jarg1;
89468   {
89469     try {
89470       (arg1)->clear();
89471     } catch (std::out_of_range& e) {
89472       {
89473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89474       };
89475     } catch (std::exception& e) {
89476       {
89477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89478       };
89479     } catch (Dali::DaliException e) {
89480       {
89481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89482       };
89483     } catch (...) {
89484       {
89485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89486       };
89487     }
89488   }
89489
89490 }
89491
89492
89493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89494   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89495   Dali::Actor *arg2 = 0 ;
89496
89497   arg1 = (std::vector< Dali::Actor > *)jarg1;
89498   arg2 = (Dali::Actor *)jarg2;
89499   if (!arg2) {
89500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89501     return ;
89502   }
89503   {
89504     try {
89505       (arg1)->push_back((Dali::Actor const &)*arg2);
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (Dali::DaliException e) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89517       };
89518     } catch (...) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89521       };
89522     }
89523   }
89524
89525 }
89526
89527
89528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89529   unsigned long jresult ;
89530   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89531   std::vector< Dali::Actor >::size_type result;
89532
89533   arg1 = (std::vector< Dali::Actor > *)jarg1;
89534   {
89535     try {
89536       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89537     } catch (std::out_of_range& e) {
89538       {
89539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89540       };
89541     } catch (std::exception& e) {
89542       {
89543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89544       };
89545     } catch (Dali::DaliException e) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89548       };
89549     } catch (...) {
89550       {
89551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89552       };
89553     }
89554   }
89555
89556   jresult = (unsigned long)result;
89557   return jresult;
89558 }
89559
89560
89561 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89562   unsigned long jresult ;
89563   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89564   std::vector< Dali::Actor >::size_type result;
89565
89566   arg1 = (std::vector< Dali::Actor > *)jarg1;
89567   {
89568     try {
89569       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89570     } catch (std::out_of_range& e) {
89571       {
89572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89573       };
89574     } catch (std::exception& e) {
89575       {
89576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89577       };
89578     } catch (Dali::DaliException e) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89581       };
89582     } catch (...) {
89583       {
89584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89585       };
89586     }
89587   }
89588
89589   jresult = (unsigned long)result;
89590   return jresult;
89591 }
89592
89593
89594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89595   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89596   std::vector< Dali::Actor >::size_type arg2 ;
89597
89598   arg1 = (std::vector< Dali::Actor > *)jarg1;
89599   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89600   {
89601     try {
89602       (arg1)->reserve(arg2);
89603     } catch (std::out_of_range& e) {
89604       {
89605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89606       };
89607     } catch (std::exception& e) {
89608       {
89609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89610       };
89611     } catch (Dali::DaliException e) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89614       };
89615     } catch (...) {
89616       {
89617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89618       };
89619     }
89620   }
89621
89622 }
89623
89624
89625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89626   void * jresult ;
89627   std::vector< Dali::Actor > *result = 0 ;
89628
89629   {
89630     try {
89631       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89632     } catch (std::out_of_range& e) {
89633       {
89634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89635       };
89636     } catch (std::exception& e) {
89637       {
89638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89639       };
89640     } catch (Dali::DaliException e) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89643       };
89644     } catch (...) {
89645       {
89646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89647       };
89648     }
89649   }
89650
89651   jresult = (void *)result;
89652   return jresult;
89653 }
89654
89655
89656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89657   void * jresult ;
89658   std::vector< Dali::Actor > *arg1 = 0 ;
89659   std::vector< Dali::Actor > *result = 0 ;
89660
89661   arg1 = (std::vector< Dali::Actor > *)jarg1;
89662   if (!arg1) {
89663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89664     return 0;
89665   }
89666   {
89667     try {
89668       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89669     } catch (std::out_of_range& e) {
89670       {
89671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89672       };
89673     } catch (std::exception& e) {
89674       {
89675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89676       };
89677     } catch (Dali::DaliException e) {
89678       {
89679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89680       };
89681     } catch (...) {
89682       {
89683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89684       };
89685     }
89686   }
89687
89688   jresult = (void *)result;
89689   return jresult;
89690 }
89691
89692
89693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89694   void * jresult ;
89695   int arg1 ;
89696   std::vector< Dali::Actor > *result = 0 ;
89697
89698   arg1 = (int)jarg1;
89699   {
89700     try {
89701       try {
89702         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89703       }
89704       catch(std::out_of_range &_e) {
89705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89706         return 0;
89707       }
89708
89709     } catch (std::out_of_range& e) {
89710       {
89711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89712       };
89713     } catch (std::exception& e) {
89714       {
89715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89716       };
89717     } catch (Dali::DaliException e) {
89718       {
89719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89720       };
89721     } catch (...) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89724       };
89725     }
89726   }
89727
89728   jresult = (void *)result;
89729   return jresult;
89730 }
89731
89732
89733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89734   void * jresult ;
89735   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89736   int arg2 ;
89737   Dali::Actor result;
89738
89739   arg1 = (std::vector< Dali::Actor > *)jarg1;
89740   arg2 = (int)jarg2;
89741   {
89742     try {
89743       try {
89744         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89745       }
89746       catch(std::out_of_range &_e) {
89747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89748         return 0;
89749       }
89750
89751     } catch (std::out_of_range& e) {
89752       {
89753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89754       };
89755     } catch (std::exception& e) {
89756       {
89757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89758       };
89759     } catch (Dali::DaliException e) {
89760       {
89761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89762       };
89763     } catch (...) {
89764       {
89765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89766       };
89767     }
89768   }
89769
89770   jresult = new Dali::Actor((const Dali::Actor &)result);
89771   return jresult;
89772 }
89773
89774
89775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89776   void * jresult ;
89777   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89778   int arg2 ;
89779   Dali::Actor *result = 0 ;
89780
89781   arg1 = (std::vector< Dali::Actor > *)jarg1;
89782   arg2 = (int)jarg2;
89783   {
89784     try {
89785       try {
89786         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89787       }
89788       catch(std::out_of_range &_e) {
89789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89790         return 0;
89791       }
89792
89793     } catch (std::out_of_range& e) {
89794       {
89795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89796       };
89797     } catch (std::exception& e) {
89798       {
89799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89800       };
89801     } catch (Dali::DaliException e) {
89802       {
89803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89804       };
89805     } catch (...) {
89806       {
89807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89808       };
89809     }
89810   }
89811
89812   jresult = (void *)result;
89813   return jresult;
89814 }
89815
89816
89817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89818   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89819   int arg2 ;
89820   Dali::Actor *arg3 = 0 ;
89821
89822   arg1 = (std::vector< Dali::Actor > *)jarg1;
89823   arg2 = (int)jarg2;
89824   arg3 = (Dali::Actor *)jarg3;
89825   if (!arg3) {
89826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89827     return ;
89828   }
89829   {
89830     try {
89831       try {
89832         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89833       }
89834       catch(std::out_of_range &_e) {
89835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89836         return ;
89837       }
89838
89839     } catch (std::out_of_range& e) {
89840       {
89841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89842       };
89843     } catch (std::exception& e) {
89844       {
89845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89846       };
89847     } catch (Dali::DaliException e) {
89848       {
89849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89850       };
89851     } catch (...) {
89852       {
89853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89854       };
89855     }
89856   }
89857
89858 }
89859
89860
89861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89862   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89863   std::vector< Dali::Actor > *arg2 = 0 ;
89864
89865   arg1 = (std::vector< Dali::Actor > *)jarg1;
89866   arg2 = (std::vector< Dali::Actor > *)jarg2;
89867   if (!arg2) {
89868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89869     return ;
89870   }
89871   {
89872     try {
89873       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89874     } catch (std::out_of_range& e) {
89875       {
89876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89877       };
89878     } catch (std::exception& e) {
89879       {
89880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89881       };
89882     } catch (Dali::DaliException e) {
89883       {
89884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89885       };
89886     } catch (...) {
89887       {
89888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89889       };
89890     }
89891   }
89892
89893 }
89894
89895
89896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89897   void * jresult ;
89898   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89899   int arg2 ;
89900   int arg3 ;
89901   std::vector< Dali::Actor > *result = 0 ;
89902
89903   arg1 = (std::vector< Dali::Actor > *)jarg1;
89904   arg2 = (int)jarg2;
89905   arg3 = (int)jarg3;
89906   {
89907     try {
89908       try {
89909         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89910       }
89911       catch(std::out_of_range &_e) {
89912         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89913         return 0;
89914       }
89915       catch(std::invalid_argument &_e) {
89916         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89917         return 0;
89918       }
89919
89920     } catch (std::out_of_range& e) {
89921       {
89922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (std::exception& e) {
89925       {
89926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89927       };
89928     } catch (Dali::DaliException e) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89931       };
89932     } catch (...) {
89933       {
89934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89935       };
89936     }
89937   }
89938
89939   jresult = (void *)result;
89940   return jresult;
89941 }
89942
89943
89944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89945   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89946   int arg2 ;
89947   Dali::Actor *arg3 = 0 ;
89948
89949   arg1 = (std::vector< Dali::Actor > *)jarg1;
89950   arg2 = (int)jarg2;
89951   arg3 = (Dali::Actor *)jarg3;
89952   if (!arg3) {
89953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89954     return ;
89955   }
89956   {
89957     try {
89958       try {
89959         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89960       }
89961       catch(std::out_of_range &_e) {
89962         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89963         return ;
89964       }
89965
89966     } catch (std::out_of_range& e) {
89967       {
89968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89969       };
89970     } catch (std::exception& e) {
89971       {
89972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89973       };
89974     } catch (Dali::DaliException e) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89977       };
89978     } catch (...) {
89979       {
89980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89981       };
89982     }
89983   }
89984
89985 }
89986
89987
89988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89989   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89990   int arg2 ;
89991   std::vector< Dali::Actor > *arg3 = 0 ;
89992
89993   arg1 = (std::vector< Dali::Actor > *)jarg1;
89994   arg2 = (int)jarg2;
89995   arg3 = (std::vector< Dali::Actor > *)jarg3;
89996   if (!arg3) {
89997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89998     return ;
89999   }
90000   {
90001     try {
90002       try {
90003         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90004       }
90005       catch(std::out_of_range &_e) {
90006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90007         return ;
90008       }
90009
90010     } catch (std::out_of_range& e) {
90011       {
90012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90013       };
90014     } catch (std::exception& e) {
90015       {
90016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90017       };
90018     } catch (Dali::DaliException e) {
90019       {
90020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90021       };
90022     } catch (...) {
90023       {
90024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90025       };
90026     }
90027   }
90028
90029 }
90030
90031
90032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
90033   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90034   int arg2 ;
90035
90036   arg1 = (std::vector< Dali::Actor > *)jarg1;
90037   arg2 = (int)jarg2;
90038   {
90039     try {
90040       try {
90041         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
90042       }
90043       catch(std::out_of_range &_e) {
90044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90045         return ;
90046       }
90047
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90063       };
90064     }
90065   }
90066
90067 }
90068
90069
90070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90071   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90072   int arg2 ;
90073   int arg3 ;
90074
90075   arg1 = (std::vector< Dali::Actor > *)jarg1;
90076   arg2 = (int)jarg2;
90077   arg3 = (int)jarg3;
90078   {
90079     try {
90080       try {
90081         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
90082       }
90083       catch(std::out_of_range &_e) {
90084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90085         return ;
90086       }
90087       catch(std::invalid_argument &_e) {
90088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90089         return ;
90090       }
90091
90092     } catch (std::out_of_range& e) {
90093       {
90094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90095       };
90096     } catch (std::exception& e) {
90097       {
90098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90099       };
90100     } catch (Dali::DaliException e) {
90101       {
90102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90103       };
90104     } catch (...) {
90105       {
90106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90107       };
90108     }
90109   }
90110
90111 }
90112
90113
90114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
90115   void * jresult ;
90116   Dali::Actor *arg1 = 0 ;
90117   int arg2 ;
90118   std::vector< Dali::Actor > *result = 0 ;
90119
90120   arg1 = (Dali::Actor *)jarg1;
90121   if (!arg1) {
90122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90123     return 0;
90124   }
90125   arg2 = (int)jarg2;
90126   {
90127     try {
90128       try {
90129         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
90130       }
90131       catch(std::out_of_range &_e) {
90132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90133         return 0;
90134       }
90135
90136     } catch (std::out_of_range& e) {
90137       {
90138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90139       };
90140     } catch (std::exception& e) {
90141       {
90142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90143       };
90144     } catch (Dali::DaliException e) {
90145       {
90146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90151       };
90152     }
90153   }
90154
90155   jresult = (void *)result;
90156   return jresult;
90157 }
90158
90159
90160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
90161   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90162
90163   arg1 = (std::vector< Dali::Actor > *)jarg1;
90164   {
90165     try {
90166       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
90167     } catch (std::out_of_range& e) {
90168       {
90169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90170       };
90171     } catch (std::exception& e) {
90172       {
90173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90174       };
90175     } catch (Dali::DaliException e) {
90176       {
90177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90178       };
90179     } catch (...) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90182       };
90183     }
90184   }
90185
90186 }
90187
90188
90189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90190   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90191   int arg2 ;
90192   int arg3 ;
90193
90194   arg1 = (std::vector< Dali::Actor > *)jarg1;
90195   arg2 = (int)jarg2;
90196   arg3 = (int)jarg3;
90197   {
90198     try {
90199       try {
90200         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90201       }
90202       catch(std::out_of_range &_e) {
90203         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90204         return ;
90205       }
90206       catch(std::invalid_argument &_e) {
90207         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90208         return ;
90209       }
90210
90211     } catch (std::out_of_range& e) {
90212       {
90213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90214       };
90215     } catch (std::exception& e) {
90216       {
90217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90218       };
90219     } catch (Dali::DaliException e) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90222       };
90223     } catch (...) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90226       };
90227     }
90228   }
90229
90230 }
90231
90232
90233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90234   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90235   int arg2 ;
90236   std::vector< Dali::Actor > *arg3 = 0 ;
90237
90238   arg1 = (std::vector< Dali::Actor > *)jarg1;
90239   arg2 = (int)jarg2;
90240   arg3 = (std::vector< Dali::Actor > *)jarg3;
90241   if (!arg3) {
90242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90243     return ;
90244   }
90245   {
90246     try {
90247       try {
90248         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90249       }
90250       catch(std::out_of_range &_e) {
90251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90252         return ;
90253       }
90254
90255     } catch (std::out_of_range& e) {
90256       {
90257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90258       };
90259     } catch (std::exception& e) {
90260       {
90261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90262       };
90263     } catch (Dali::DaliException e) {
90264       {
90265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90266       };
90267     } catch (...) {
90268       {
90269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90270       };
90271     }
90272   }
90273
90274 }
90275
90276
90277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90278   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90279
90280   arg1 = (std::vector< Dali::Actor > *)jarg1;
90281   {
90282     try {
90283       delete arg1;
90284     } catch (std::out_of_range& e) {
90285       {
90286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90287       };
90288     } catch (std::exception& e) {
90289       {
90290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90291       };
90292     } catch (Dali::DaliException e) {
90293       {
90294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90295       };
90296     } catch (...) {
90297       {
90298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90299       };
90300     }
90301   }
90302
90303 }
90304
90305
90306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90307   unsigned int jresult ;
90308   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90309   bool result;
90310
90311   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90312   {
90313     try {
90314       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90315     } catch (std::out_of_range& e) {
90316       {
90317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90318       };
90319     } catch (std::exception& e) {
90320       {
90321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (Dali::DaliException e) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90330       };
90331     }
90332   }
90333
90334   jresult = result;
90335   return jresult;
90336 }
90337
90338
90339 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90340   unsigned long jresult ;
90341   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90342   std::size_t result;
90343
90344   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90345   {
90346     try {
90347       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90348     } catch (std::out_of_range& e) {
90349       {
90350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (std::exception& e) {
90353       {
90354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (Dali::DaliException e) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90363       };
90364     }
90365   }
90366
90367   jresult = (unsigned long)result;
90368   return jresult;
90369 }
90370
90371
90372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90373   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90374   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90375
90376   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90377   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90378   {
90379     try {
90380       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90381     } catch (std::out_of_range& e) {
90382       {
90383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90384       };
90385     } catch (std::exception& e) {
90386       {
90387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90388       };
90389     } catch (Dali::DaliException e) {
90390       {
90391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90392       };
90393     } catch (...) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90396       };
90397     }
90398   }
90399
90400 }
90401
90402
90403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90404   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90405   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90406
90407   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90408   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90409   {
90410     try {
90411       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90412     } catch (std::out_of_range& e) {
90413       {
90414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90415       };
90416     } catch (std::exception& e) {
90417       {
90418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90419       };
90420     } catch (Dali::DaliException e) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90423       };
90424     } catch (...) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90427       };
90428     }
90429   }
90430
90431 }
90432
90433
90434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90435   unsigned int jresult ;
90436   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90437   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90438   bool result;
90439
90440   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90441   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90442   if (!arg2) {
90443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90444     return 0;
90445   }
90446   {
90447     try {
90448       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90449     } catch (std::out_of_range& e) {
90450       {
90451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (std::exception& e) {
90454       {
90455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90456       };
90457     } catch (Dali::DaliException e) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90460       };
90461     } catch (...) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90464       };
90465     }
90466   }
90467
90468   jresult = result;
90469   return jresult;
90470 }
90471
90472
90473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90474   void * jresult ;
90475   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90476
90477   {
90478     try {
90479       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (Dali::DaliException e) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90495       };
90496     }
90497   }
90498
90499   jresult = (void *)result;
90500   return jresult;
90501 }
90502
90503
90504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90505   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90506
90507   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90508   {
90509     try {
90510       delete arg1;
90511     } catch (std::out_of_range& e) {
90512       {
90513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90514       };
90515     } catch (std::exception& e) {
90516       {
90517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90518       };
90519     } catch (Dali::DaliException e) {
90520       {
90521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90522       };
90523     } catch (...) {
90524       {
90525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90526       };
90527     }
90528   }
90529
90530 }
90531
90532
90533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90534   unsigned int jresult ;
90535   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90536   bool result;
90537
90538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90539   {
90540     try {
90541       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);
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (Dali::DaliException e) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90553       };
90554     } catch (...) {
90555       {
90556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90557       };
90558     }
90559   }
90560
90561   jresult = result;
90562   return jresult;
90563 }
90564
90565
90566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90567   unsigned long jresult ;
90568   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90569   std::size_t result;
90570
90571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90572   {
90573     try {
90574       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);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90582       };
90583     } catch (Dali::DaliException e) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90590       };
90591     }
90592   }
90593
90594   jresult = (unsigned long)result;
90595   return jresult;
90596 }
90597
90598
90599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90600   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90601   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90602
90603   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90604   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90605   {
90606     try {
90607       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90608     } catch (std::out_of_range& e) {
90609       {
90610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90611       };
90612     } catch (std::exception& e) {
90613       {
90614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90615       };
90616     } catch (Dali::DaliException e) {
90617       {
90618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90619       };
90620     } catch (...) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90623       };
90624     }
90625   }
90626
90627 }
90628
90629
90630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90631   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90632   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90633
90634   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90635   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90636   {
90637     try {
90638       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90639     } catch (std::out_of_range& e) {
90640       {
90641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90642       };
90643     } catch (std::exception& e) {
90644       {
90645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90646       };
90647     } catch (Dali::DaliException e) {
90648       {
90649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90650       };
90651     } catch (...) {
90652       {
90653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90654       };
90655     }
90656   }
90657
90658 }
90659
90660
90661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90662   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90663   Dali::Actor arg2 ;
90664   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90665   Dali::Actor *argp2 ;
90666
90667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90668   argp2 = (Dali::Actor *)jarg2;
90669   if (!argp2) {
90670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90671     return ;
90672   }
90673   arg2 = *argp2;
90674   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90675   {
90676     try {
90677       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90685       };
90686     } catch (Dali::DaliException e) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90693       };
90694     }
90695   }
90696
90697 }
90698
90699
90700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90701   void * jresult ;
90702   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90703
90704   {
90705     try {
90706       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90707     } catch (std::out_of_range& e) {
90708       {
90709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90710       };
90711     } catch (std::exception& e) {
90712       {
90713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90714       };
90715     } catch (Dali::DaliException e) {
90716       {
90717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90718       };
90719     } catch (...) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90722       };
90723     }
90724   }
90725
90726   jresult = (void *)result;
90727   return jresult;
90728 }
90729
90730
90731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90732   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90733
90734   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90735   {
90736     try {
90737       delete arg1;
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90753       };
90754     }
90755   }
90756
90757 }
90758
90759
90760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90761   unsigned int jresult ;
90762   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90763   bool result;
90764
90765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90766   {
90767     try {
90768       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90769     } catch (std::out_of_range& e) {
90770       {
90771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90772       };
90773     } catch (std::exception& e) {
90774       {
90775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90776       };
90777     } catch (Dali::DaliException e) {
90778       {
90779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90780       };
90781     } catch (...) {
90782       {
90783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90784       };
90785     }
90786   }
90787
90788   jresult = result;
90789   return jresult;
90790 }
90791
90792
90793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90794   unsigned long jresult ;
90795   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90796   std::size_t result;
90797
90798   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90799   {
90800     try {
90801       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90802     } catch (std::out_of_range& e) {
90803       {
90804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90805       };
90806     } catch (std::exception& e) {
90807       {
90808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90809       };
90810     } catch (Dali::DaliException e) {
90811       {
90812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90813       };
90814     } catch (...) {
90815       {
90816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90817       };
90818     }
90819   }
90820
90821   jresult = (unsigned long)result;
90822   return jresult;
90823 }
90824
90825
90826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90827   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90828   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90829
90830   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90831   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90832   {
90833     try {
90834       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90835     } catch (std::out_of_range& e) {
90836       {
90837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90838       };
90839     } catch (std::exception& e) {
90840       {
90841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90842       };
90843     } catch (Dali::DaliException e) {
90844       {
90845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90846       };
90847     } catch (...) {
90848       {
90849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90850       };
90851     }
90852   }
90853
90854 }
90855
90856
90857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90858   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90859   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90860
90861   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90862   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90863   {
90864     try {
90865       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90866     } catch (std::out_of_range& e) {
90867       {
90868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90869       };
90870     } catch (std::exception& e) {
90871       {
90872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90873       };
90874     } catch (Dali::DaliException e) {
90875       {
90876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90877       };
90878     } catch (...) {
90879       {
90880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90881       };
90882     }
90883   }
90884
90885 }
90886
90887
90888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90889   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90890   Dali::Actor arg2 ;
90891   Dali::Actor arg3 ;
90892   Dali::Actor *argp2 ;
90893   Dali::Actor *argp3 ;
90894
90895   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90896   argp2 = (Dali::Actor *)jarg2;
90897   if (!argp2) {
90898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90899     return ;
90900   }
90901   arg2 = *argp2;
90902   argp3 = (Dali::Actor *)jarg3;
90903   if (!argp3) {
90904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90905     return ;
90906   }
90907   arg3 = *argp3;
90908   {
90909     try {
90910       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90911     } catch (std::out_of_range& e) {
90912       {
90913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90914       };
90915     } catch (std::exception& e) {
90916       {
90917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90918       };
90919     } catch (Dali::DaliException e) {
90920       {
90921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90922       };
90923     } catch (...) {
90924       {
90925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90926       };
90927     }
90928   }
90929
90930 }
90931
90932
90933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90934   void * jresult ;
90935   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90936
90937   {
90938     try {
90939       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90940     } catch (std::out_of_range& e) {
90941       {
90942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (std::exception& e) {
90945       {
90946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90947       };
90948     } catch (Dali::DaliException e) {
90949       {
90950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90951       };
90952     } catch (...) {
90953       {
90954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90955       };
90956     }
90957   }
90958
90959   jresult = (void *)result;
90960   return jresult;
90961 }
90962
90963
90964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90965   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90966
90967   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90968   {
90969     try {
90970       delete arg1;
90971     } catch (std::out_of_range& e) {
90972       {
90973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90974       };
90975     } catch (std::exception& e) {
90976       {
90977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90978       };
90979     } catch (Dali::DaliException e) {
90980       {
90981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90982       };
90983     } catch (...) {
90984       {
90985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90986       };
90987     }
90988   }
90989
90990 }
90991
90992
90993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90994   unsigned int jresult ;
90995   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90996   bool result;
90997
90998   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90999   {
91000     try {
91001       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91002     } catch (std::out_of_range& e) {
91003       {
91004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91005       };
91006     } catch (std::exception& e) {
91007       {
91008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91009       };
91010     } catch (Dali::DaliException e) {
91011       {
91012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91013       };
91014     } catch (...) {
91015       {
91016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91017       };
91018     }
91019   }
91020
91021   jresult = result;
91022   return jresult;
91023 }
91024
91025
91026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
91027   unsigned long jresult ;
91028   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91029   std::size_t result;
91030
91031   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91032   {
91033     try {
91034       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91042       };
91043     } catch (Dali::DaliException e) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91050       };
91051     }
91052   }
91053
91054   jresult = (unsigned long)result;
91055   return jresult;
91056 }
91057
91058
91059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
91060   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91061   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91062
91063   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91064   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91065   {
91066     try {
91067       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
91068     } catch (std::out_of_range& e) {
91069       {
91070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91071       };
91072     } catch (std::exception& e) {
91073       {
91074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91075       };
91076     } catch (Dali::DaliException e) {
91077       {
91078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91079       };
91080     } catch (...) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91083       };
91084     }
91085   }
91086
91087 }
91088
91089
91090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91091   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91092   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91093
91094   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91095   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91096   {
91097     try {
91098       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91099     } catch (std::out_of_range& e) {
91100       {
91101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91102       };
91103     } catch (std::exception& e) {
91104       {
91105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91106       };
91107     } catch (Dali::DaliException e) {
91108       {
91109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91110       };
91111     } catch (...) {
91112       {
91113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91114       };
91115     }
91116   }
91117
91118 }
91119
91120
91121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
91122   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91123   Dali::Actor arg2 ;
91124   bool arg3 ;
91125   Dali::Actor *argp2 ;
91126
91127   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91128   argp2 = (Dali::Actor *)jarg2;
91129   if (!argp2) {
91130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91131     return ;
91132   }
91133   arg2 = *argp2;
91134   arg3 = jarg3 ? true : false;
91135   {
91136     try {
91137       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
91138     } catch (std::out_of_range& e) {
91139       {
91140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91141       };
91142     } catch (std::exception& e) {
91143       {
91144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91145       };
91146     } catch (Dali::DaliException e) {
91147       {
91148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91149       };
91150     } catch (...) {
91151       {
91152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91153       };
91154     }
91155   }
91156
91157 }
91158
91159
91160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
91161   void * jresult ;
91162   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
91163
91164   {
91165     try {
91166       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
91167     } catch (std::out_of_range& e) {
91168       {
91169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91170       };
91171     } catch (std::exception& e) {
91172       {
91173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91174       };
91175     } catch (Dali::DaliException e) {
91176       {
91177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91178       };
91179     } catch (...) {
91180       {
91181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91182       };
91183     }
91184   }
91185
91186   jresult = (void *)result;
91187   return jresult;
91188 }
91189
91190
91191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91192   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91193
91194   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91195   {
91196     try {
91197       delete arg1;
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (Dali::DaliException e) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91209       };
91210     } catch (...) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91213       };
91214     }
91215   }
91216
91217 }
91218
91219
91220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91221   unsigned int jresult ;
91222   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91223   bool result;
91224
91225   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91226   {
91227     try {
91228       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);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91244       };
91245     }
91246   }
91247
91248   jresult = result;
91249   return jresult;
91250 }
91251
91252
91253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91254   unsigned long jresult ;
91255   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91256   std::size_t result;
91257
91258   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91259   {
91260     try {
91261       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);
91262     } catch (std::out_of_range& e) {
91263       {
91264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91265       };
91266     } catch (std::exception& e) {
91267       {
91268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91269       };
91270     } catch (Dali::DaliException e) {
91271       {
91272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91273       };
91274     } catch (...) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91277       };
91278     }
91279   }
91280
91281   jresult = (unsigned long)result;
91282   return jresult;
91283 }
91284
91285
91286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91287   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91288   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91289
91290   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91291   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91292   {
91293     try {
91294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91295     } catch (std::out_of_range& e) {
91296       {
91297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91298       };
91299     } catch (std::exception& e) {
91300       {
91301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91302       };
91303     } catch (Dali::DaliException e) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91306       };
91307     } catch (...) {
91308       {
91309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91310       };
91311     }
91312   }
91313
91314 }
91315
91316
91317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91318   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91319   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91320
91321   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91322   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91323   {
91324     try {
91325       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91326     } catch (std::out_of_range& e) {
91327       {
91328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91329       };
91330     } catch (std::exception& e) {
91331       {
91332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91333       };
91334     } catch (Dali::DaliException e) {
91335       {
91336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91337       };
91338     } catch (...) {
91339       {
91340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91341       };
91342     }
91343   }
91344
91345 }
91346
91347
91348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91349   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91350   Dali::Toolkit::StyleManager arg2 ;
91351   Dali::StyleChange::Type arg3 ;
91352   Dali::Toolkit::StyleManager *argp2 ;
91353
91354   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91355   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91356   if (!argp2) {
91357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91358     return ;
91359   }
91360   arg2 = *argp2;
91361   arg3 = (Dali::StyleChange::Type)jarg3;
91362   {
91363     try {
91364       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (Dali::DaliException e) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91380       };
91381     }
91382   }
91383
91384 }
91385
91386
91387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91388   void * jresult ;
91389   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91390
91391   {
91392     try {
91393       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91394     } catch (std::out_of_range& e) {
91395       {
91396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91397       };
91398     } catch (std::exception& e) {
91399       {
91400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91401       };
91402     } catch (Dali::DaliException e) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91409       };
91410     }
91411   }
91412
91413   jresult = (void *)result;
91414   return jresult;
91415 }
91416
91417
91418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91419   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91420
91421   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91422   {
91423     try {
91424       delete arg1;
91425     } catch (std::out_of_range& e) {
91426       {
91427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91428       };
91429     } catch (std::exception& e) {
91430       {
91431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (Dali::DaliException e) {
91434       {
91435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91436       };
91437     } catch (...) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91440       };
91441     }
91442   }
91443
91444 }
91445
91446
91447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91448   unsigned int jresult ;
91449   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91450   bool result;
91451
91452   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91453   {
91454     try {
91455       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91456     } catch (std::out_of_range& e) {
91457       {
91458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (std::exception& e) {
91461       {
91462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (Dali::DaliException e) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91467       };
91468     } catch (...) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91471       };
91472     }
91473   }
91474
91475   jresult = result;
91476   return jresult;
91477 }
91478
91479
91480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91481   unsigned long jresult ;
91482   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91483   std::size_t result;
91484
91485   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91486   {
91487     try {
91488       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91489     } catch (std::out_of_range& e) {
91490       {
91491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91492       };
91493     } catch (std::exception& e) {
91494       {
91495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91496       };
91497     } catch (Dali::DaliException e) {
91498       {
91499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91500       };
91501     } catch (...) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91504       };
91505     }
91506   }
91507
91508   jresult = (unsigned long)result;
91509   return jresult;
91510 }
91511
91512
91513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91514   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91515   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91516
91517   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91518   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91519   {
91520     try {
91521       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91537       };
91538     }
91539   }
91540
91541 }
91542
91543
91544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91545   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91546   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91547
91548   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91549   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91550   {
91551     try {
91552       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91553     } catch (std::out_of_range& e) {
91554       {
91555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91556       };
91557     } catch (std::exception& e) {
91558       {
91559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91560       };
91561     } catch (Dali::DaliException e) {
91562       {
91563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91564       };
91565     } catch (...) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91568       };
91569     }
91570   }
91571
91572 }
91573
91574
91575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91576   unsigned int jresult ;
91577   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91578   Dali::Toolkit::Button arg2 ;
91579   Dali::Toolkit::Button *argp2 ;
91580   bool result;
91581
91582   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91583   argp2 = (Dali::Toolkit::Button *)jarg2;
91584   if (!argp2) {
91585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91586     return 0;
91587   }
91588   arg2 = *argp2;
91589   {
91590     try {
91591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91592     } catch (std::out_of_range& e) {
91593       {
91594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (std::exception& e) {
91597       {
91598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91599       };
91600     } catch (Dali::DaliException e) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91603       };
91604     } catch (...) {
91605       {
91606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91607       };
91608     }
91609   }
91610
91611   jresult = result;
91612   return jresult;
91613 }
91614
91615
91616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91617   void * jresult ;
91618   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91619
91620   {
91621     try {
91622       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91623     } catch (std::out_of_range& e) {
91624       {
91625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91626       };
91627     } catch (std::exception& e) {
91628       {
91629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91630       };
91631     } catch (Dali::DaliException e) {
91632       {
91633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91634       };
91635     } catch (...) {
91636       {
91637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91638       };
91639     }
91640   }
91641
91642   jresult = (void *)result;
91643   return jresult;
91644 }
91645
91646
91647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91648   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91649
91650   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91651   {
91652     try {
91653       delete arg1;
91654     } catch (std::out_of_range& e) {
91655       {
91656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91657       };
91658     } catch (std::exception& e) {
91659       {
91660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91661       };
91662     } catch (Dali::DaliException e) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91665       };
91666     } catch (...) {
91667       {
91668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91669       };
91670     }
91671   }
91672
91673 }
91674
91675
91676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91677   unsigned int jresult ;
91678   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91679   bool result;
91680
91681   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91682   {
91683     try {
91684       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91685     } catch (std::out_of_range& e) {
91686       {
91687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91688       };
91689     } catch (std::exception& e) {
91690       {
91691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91692       };
91693     } catch (Dali::DaliException e) {
91694       {
91695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91696       };
91697     } catch (...) {
91698       {
91699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91700       };
91701     }
91702   }
91703
91704   jresult = result;
91705   return jresult;
91706 }
91707
91708
91709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91710   unsigned long jresult ;
91711   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91712   std::size_t result;
91713
91714   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91715   {
91716     try {
91717       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91718     } catch (std::out_of_range& e) {
91719       {
91720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91721       };
91722     } catch (std::exception& e) {
91723       {
91724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91725       };
91726     } catch (Dali::DaliException e) {
91727       {
91728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91729       };
91730     } catch (...) {
91731       {
91732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91733       };
91734     }
91735   }
91736
91737   jresult = (unsigned long)result;
91738   return jresult;
91739 }
91740
91741
91742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91743   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91744   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91745
91746   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91747   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91748   {
91749     try {
91750       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91751     } catch (std::out_of_range& e) {
91752       {
91753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91754       };
91755     } catch (std::exception& e) {
91756       {
91757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91758       };
91759     } catch (Dali::DaliException e) {
91760       {
91761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91762       };
91763     } catch (...) {
91764       {
91765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91766       };
91767     }
91768   }
91769
91770 }
91771
91772
91773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91774   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91775   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91776
91777   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91778   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91779   {
91780     try {
91781       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91782     } catch (std::out_of_range& e) {
91783       {
91784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91785       };
91786     } catch (std::exception& e) {
91787       {
91788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91789       };
91790     } catch (Dali::DaliException e) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91793       };
91794     } catch (...) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91797       };
91798     }
91799   }
91800
91801 }
91802
91803
91804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91805   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91806   Dali::Toolkit::GaussianBlurView arg2 ;
91807   Dali::Toolkit::GaussianBlurView *argp2 ;
91808
91809   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91810   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91811   if (!argp2) {
91812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91813     return ;
91814   }
91815   arg2 = *argp2;
91816   {
91817     try {
91818       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91819     } catch (std::out_of_range& e) {
91820       {
91821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91822       };
91823     } catch (std::exception& e) {
91824       {
91825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91826       };
91827     } catch (Dali::DaliException e) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91830       };
91831     } catch (...) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91834       };
91835     }
91836   }
91837
91838 }
91839
91840
91841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91842   void * jresult ;
91843   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91844
91845   {
91846     try {
91847       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91848     } catch (std::out_of_range& e) {
91849       {
91850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91851       };
91852     } catch (std::exception& e) {
91853       {
91854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91855       };
91856     } catch (Dali::DaliException e) {
91857       {
91858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91859       };
91860     } catch (...) {
91861       {
91862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91863       };
91864     }
91865   }
91866
91867   jresult = (void *)result;
91868   return jresult;
91869 }
91870
91871
91872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91873   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91874
91875   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91876   {
91877     try {
91878       delete arg1;
91879     } catch (std::out_of_range& e) {
91880       {
91881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91882       };
91883     } catch (std::exception& e) {
91884       {
91885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91886       };
91887     } catch (Dali::DaliException e) {
91888       {
91889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91890       };
91891     } catch (...) {
91892       {
91893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91894       };
91895     }
91896   }
91897
91898 }
91899
91900
91901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91902   unsigned int jresult ;
91903   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91904   bool result;
91905
91906   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91907   {
91908     try {
91909       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);
91910     } catch (std::out_of_range& e) {
91911       {
91912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91913       };
91914     } catch (std::exception& e) {
91915       {
91916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91917       };
91918     } catch (Dali::DaliException e) {
91919       {
91920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91921       };
91922     } catch (...) {
91923       {
91924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91925       };
91926     }
91927   }
91928
91929   jresult = result;
91930   return jresult;
91931 }
91932
91933
91934 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91935   unsigned long jresult ;
91936   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91937   std::size_t result;
91938
91939   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91940   {
91941     try {
91942       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);
91943     } catch (std::out_of_range& e) {
91944       {
91945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91946       };
91947     } catch (std::exception& e) {
91948       {
91949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (Dali::DaliException e) {
91952       {
91953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91954       };
91955     } catch (...) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91958       };
91959     }
91960   }
91961
91962   jresult = (unsigned long)result;
91963   return jresult;
91964 }
91965
91966
91967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91968   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91969   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91970
91971   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91972   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91973   {
91974     try {
91975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91976     } catch (std::out_of_range& e) {
91977       {
91978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91979       };
91980     } catch (std::exception& e) {
91981       {
91982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91983       };
91984     } catch (Dali::DaliException e) {
91985       {
91986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91987       };
91988     } catch (...) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91991       };
91992     }
91993   }
91994
91995 }
91996
91997
91998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91999   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92000   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92001
92002   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92003   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92004   {
92005     try {
92006       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
92007     } catch (std::out_of_range& e) {
92008       {
92009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92010       };
92011     } catch (std::exception& e) {
92012       {
92013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92014       };
92015     } catch (Dali::DaliException e) {
92016       {
92017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92018       };
92019     } catch (...) {
92020       {
92021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92022       };
92023     }
92024   }
92025
92026 }
92027
92028
92029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
92030   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92031   Dali::Toolkit::PageTurnView arg2 ;
92032   unsigned int arg3 ;
92033   bool arg4 ;
92034   Dali::Toolkit::PageTurnView *argp2 ;
92035
92036   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92037   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92038   if (!argp2) {
92039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92040     return ;
92041   }
92042   arg2 = *argp2;
92043   arg3 = (unsigned int)jarg3;
92044   arg4 = jarg4 ? true : false;
92045   {
92046     try {
92047       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92048     } catch (std::out_of_range& e) {
92049       {
92050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92051       };
92052     } catch (std::exception& e) {
92053       {
92054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92055       };
92056     } catch (Dali::DaliException e) {
92057       {
92058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92059       };
92060     } catch (...) {
92061       {
92062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92063       };
92064     }
92065   }
92066
92067 }
92068
92069
92070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
92071   void * jresult ;
92072   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
92073
92074   {
92075     try {
92076       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
92077     } catch (std::out_of_range& e) {
92078       {
92079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92080       };
92081     } catch (std::exception& e) {
92082       {
92083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92084       };
92085     } catch (Dali::DaliException e) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92088       };
92089     } catch (...) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92092       };
92093     }
92094   }
92095
92096   jresult = (void *)result;
92097   return jresult;
92098 }
92099
92100
92101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
92102   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92103
92104   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92105   {
92106     try {
92107       delete arg1;
92108     } catch (std::out_of_range& e) {
92109       {
92110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (std::exception& e) {
92113       {
92114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92115       };
92116     } catch (Dali::DaliException e) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92119       };
92120     } catch (...) {
92121       {
92122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92123       };
92124     }
92125   }
92126
92127 }
92128
92129
92130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
92131   unsigned int jresult ;
92132   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92133   bool result;
92134
92135   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92136   {
92137     try {
92138       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92139     } catch (std::out_of_range& e) {
92140       {
92141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92142       };
92143     } catch (std::exception& e) {
92144       {
92145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92146       };
92147     } catch (Dali::DaliException e) {
92148       {
92149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92150       };
92151     } catch (...) {
92152       {
92153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92154       };
92155     }
92156   }
92157
92158   jresult = result;
92159   return jresult;
92160 }
92161
92162
92163 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
92164   unsigned long jresult ;
92165   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92166   std::size_t result;
92167
92168   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92169   {
92170     try {
92171       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92172     } catch (std::out_of_range& e) {
92173       {
92174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92175       };
92176     } catch (std::exception& e) {
92177       {
92178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92179       };
92180     } catch (Dali::DaliException e) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92183       };
92184     } catch (...) {
92185       {
92186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92187       };
92188     }
92189   }
92190
92191   jresult = (unsigned long)result;
92192   return jresult;
92193 }
92194
92195
92196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92197   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92198   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92199
92200   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92201   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92202   {
92203     try {
92204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92205     } catch (std::out_of_range& e) {
92206       {
92207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92208       };
92209     } catch (std::exception& e) {
92210       {
92211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92212       };
92213     } catch (Dali::DaliException e) {
92214       {
92215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92216       };
92217     } catch (...) {
92218       {
92219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92220       };
92221     }
92222   }
92223
92224 }
92225
92226
92227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92228   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92229   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92230
92231   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92232   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92233   {
92234     try {
92235       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92236     } catch (std::out_of_range& e) {
92237       {
92238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92239       };
92240     } catch (std::exception& e) {
92241       {
92242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92243       };
92244     } catch (Dali::DaliException e) {
92245       {
92246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92247       };
92248     } catch (...) {
92249       {
92250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92251       };
92252     }
92253   }
92254
92255 }
92256
92257
92258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92259   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92260   Dali::Toolkit::PageTurnView arg2 ;
92261   Dali::Toolkit::PageTurnView *argp2 ;
92262
92263   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92264   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92265   if (!argp2) {
92266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92267     return ;
92268   }
92269   arg2 = *argp2;
92270   {
92271     try {
92272       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92273     } catch (std::out_of_range& e) {
92274       {
92275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92276       };
92277     } catch (std::exception& e) {
92278       {
92279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92280       };
92281     } catch (Dali::DaliException e) {
92282       {
92283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92284       };
92285     } catch (...) {
92286       {
92287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92288       };
92289     }
92290   }
92291
92292 }
92293
92294
92295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92296   void * jresult ;
92297   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92298
92299   {
92300     try {
92301       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92302     } catch (std::out_of_range& e) {
92303       {
92304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92305       };
92306     } catch (std::exception& e) {
92307       {
92308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92309       };
92310     } catch (Dali::DaliException e) {
92311       {
92312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92313       };
92314     } catch (...) {
92315       {
92316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92317       };
92318     }
92319   }
92320
92321   jresult = (void *)result;
92322   return jresult;
92323 }
92324
92325
92326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92327   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92328
92329   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92330   {
92331     try {
92332       delete arg1;
92333     } catch (std::out_of_range& e) {
92334       {
92335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92336       };
92337     } catch (std::exception& e) {
92338       {
92339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92340       };
92341     } catch (Dali::DaliException e) {
92342       {
92343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92344       };
92345     } catch (...) {
92346       {
92347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92348       };
92349     }
92350   }
92351
92352 }
92353
92354
92355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92356   unsigned int jresult ;
92357   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92358   bool result;
92359
92360   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92361   {
92362     try {
92363       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
92364     } catch (std::out_of_range& e) {
92365       {
92366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92367       };
92368     } catch (std::exception& e) {
92369       {
92370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92371       };
92372     } catch (Dali::DaliException e) {
92373       {
92374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92375       };
92376     } catch (...) {
92377       {
92378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92379       };
92380     }
92381   }
92382
92383   jresult = result;
92384   return jresult;
92385 }
92386
92387
92388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92389   unsigned long jresult ;
92390   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92391   std::size_t result;
92392
92393   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92394   {
92395     try {
92396       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
92397     } catch (std::out_of_range& e) {
92398       {
92399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92400       };
92401     } catch (std::exception& e) {
92402       {
92403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92404       };
92405     } catch (Dali::DaliException e) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92408       };
92409     } catch (...) {
92410       {
92411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92412       };
92413     }
92414   }
92415
92416   jresult = (unsigned long)result;
92417   return jresult;
92418 }
92419
92420
92421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92422   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92423   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92424
92425   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92426   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92427   {
92428     try {
92429       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92430     } catch (std::out_of_range& e) {
92431       {
92432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92433       };
92434     } catch (std::exception& e) {
92435       {
92436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92437       };
92438     } catch (Dali::DaliException e) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92441       };
92442     } catch (...) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92445       };
92446     }
92447   }
92448
92449 }
92450
92451
92452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92453   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92454   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92455
92456   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92457   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92458   {
92459     try {
92460       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92461     } catch (std::out_of_range& e) {
92462       {
92463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92464       };
92465     } catch (std::exception& e) {
92466       {
92467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92468       };
92469     } catch (Dali::DaliException e) {
92470       {
92471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92472       };
92473     } catch (...) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92476       };
92477     }
92478   }
92479
92480 }
92481
92482
92483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92484   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92485   Dali::Toolkit::ProgressBar arg2 ;
92486   float arg3 ;
92487   float arg4 ;
92488   Dali::Toolkit::ProgressBar *argp2 ;
92489
92490   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92491   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92492   if (!argp2) {
92493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92494     return ;
92495   }
92496   arg2 = *argp2;
92497   arg3 = (float)jarg3;
92498   arg4 = (float)jarg4;
92499   {
92500     try {
92501       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92502     } catch (std::out_of_range& e) {
92503       {
92504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92505       };
92506     } catch (std::exception& e) {
92507       {
92508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92509       };
92510     } catch (Dali::DaliException e) {
92511       {
92512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92513       };
92514     } catch (...) {
92515       {
92516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92517       };
92518     }
92519   }
92520
92521 }
92522
92523
92524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92525   void * jresult ;
92526   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92527
92528   {
92529     try {
92530       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92531     } catch (std::out_of_range& e) {
92532       {
92533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92534       };
92535     } catch (std::exception& e) {
92536       {
92537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92538       };
92539     } catch (Dali::DaliException e) {
92540       {
92541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92542       };
92543     } catch (...) {
92544       {
92545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92546       };
92547     }
92548   }
92549
92550   jresult = (void *)result;
92551   return jresult;
92552 }
92553
92554
92555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92556   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92557
92558   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92559   {
92560     try {
92561       delete arg1;
92562     } catch (std::out_of_range& e) {
92563       {
92564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92565       };
92566     } catch (std::exception& e) {
92567       {
92568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92569       };
92570     } catch (Dali::DaliException e) {
92571       {
92572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92573       };
92574     } catch (...) {
92575       {
92576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92577       };
92578     }
92579   }
92580
92581 }
92582
92583
92584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92585   unsigned int jresult ;
92586   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92587   bool result;
92588
92589   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92590   {
92591     try {
92592       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);
92593     } catch (std::out_of_range& e) {
92594       {
92595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92596       };
92597     } catch (std::exception& e) {
92598       {
92599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92600       };
92601     } catch (Dali::DaliException e) {
92602       {
92603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92604       };
92605     } catch (...) {
92606       {
92607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92608       };
92609     }
92610   }
92611
92612   jresult = result;
92613   return jresult;
92614 }
92615
92616
92617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92618   unsigned long jresult ;
92619   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92620   std::size_t result;
92621
92622   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92623   {
92624     try {
92625       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);
92626     } catch (std::out_of_range& e) {
92627       {
92628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92629       };
92630     } catch (std::exception& e) {
92631       {
92632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92633       };
92634     } catch (Dali::DaliException e) {
92635       {
92636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92637       };
92638     } catch (...) {
92639       {
92640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92641       };
92642     }
92643   }
92644
92645   jresult = (unsigned long)result;
92646   return jresult;
92647 }
92648
92649
92650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92651   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92652   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92653
92654   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92655   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92656   {
92657     try {
92658       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92659     } catch (std::out_of_range& e) {
92660       {
92661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92662       };
92663     } catch (std::exception& e) {
92664       {
92665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92666       };
92667     } catch (Dali::DaliException e) {
92668       {
92669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92670       };
92671     } catch (...) {
92672       {
92673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92674       };
92675     }
92676   }
92677
92678 }
92679
92680
92681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92682   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92683   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92684
92685   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92686   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92687   {
92688     try {
92689       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92690     } catch (std::out_of_range& e) {
92691       {
92692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92693       };
92694     } catch (std::exception& e) {
92695       {
92696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92697       };
92698     } catch (Dali::DaliException e) {
92699       {
92700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92701       };
92702     } catch (...) {
92703       {
92704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92705       };
92706     }
92707   }
92708
92709 }
92710
92711
92712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92713   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92714   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92715
92716   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92717   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92718   if (!arg2) {
92719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92720     return ;
92721   }
92722   {
92723     try {
92724       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92725     } catch (std::out_of_range& e) {
92726       {
92727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92728       };
92729     } catch (std::exception& e) {
92730       {
92731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92732       };
92733     } catch (Dali::DaliException e) {
92734       {
92735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92736       };
92737     } catch (...) {
92738       {
92739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92740       };
92741     }
92742   }
92743
92744 }
92745
92746
92747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92748   void * jresult ;
92749   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92750
92751   {
92752     try {
92753       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92754     } catch (std::out_of_range& e) {
92755       {
92756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92757       };
92758     } catch (std::exception& e) {
92759       {
92760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92761       };
92762     } catch (Dali::DaliException e) {
92763       {
92764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92765       };
92766     } catch (...) {
92767       {
92768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92769       };
92770     }
92771   }
92772
92773   jresult = (void *)result;
92774   return jresult;
92775 }
92776
92777
92778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92779   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92780
92781   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92782   {
92783     try {
92784       delete arg1;
92785     } catch (std::out_of_range& e) {
92786       {
92787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92788       };
92789     } catch (std::exception& e) {
92790       {
92791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92792       };
92793     } catch (Dali::DaliException e) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92796       };
92797     } catch (...) {
92798       {
92799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92800       };
92801     }
92802   }
92803
92804 }
92805
92806
92807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92808   unsigned int jresult ;
92809   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92810   bool result;
92811
92812   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92813   {
92814     try {
92815       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92816     } catch (std::out_of_range& e) {
92817       {
92818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (std::exception& e) {
92821       {
92822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92823       };
92824     } catch (Dali::DaliException e) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92827       };
92828     } catch (...) {
92829       {
92830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92831       };
92832     }
92833   }
92834
92835   jresult = result;
92836   return jresult;
92837 }
92838
92839
92840 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92841   unsigned long jresult ;
92842   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92843   std::size_t result;
92844
92845   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92846   {
92847     try {
92848       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92849     } catch (std::out_of_range& e) {
92850       {
92851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92852       };
92853     } catch (std::exception& e) {
92854       {
92855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92856       };
92857     } catch (Dali::DaliException e) {
92858       {
92859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92860       };
92861     } catch (...) {
92862       {
92863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92864       };
92865     }
92866   }
92867
92868   jresult = (unsigned long)result;
92869   return jresult;
92870 }
92871
92872
92873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92874   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92875   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92876
92877   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92878   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92879   {
92880     try {
92881       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92882     } catch (std::out_of_range& e) {
92883       {
92884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92885       };
92886     } catch (std::exception& e) {
92887       {
92888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92889       };
92890     } catch (Dali::DaliException e) {
92891       {
92892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92893       };
92894     } catch (...) {
92895       {
92896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92897       };
92898     }
92899   }
92900
92901 }
92902
92903
92904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92905   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92906   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92907
92908   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92909   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92910   {
92911     try {
92912       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92913     } catch (std::out_of_range& e) {
92914       {
92915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92916       };
92917     } catch (std::exception& e) {
92918       {
92919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92920       };
92921     } catch (Dali::DaliException e) {
92922       {
92923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92924       };
92925     } catch (...) {
92926       {
92927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92928       };
92929     }
92930   }
92931
92932 }
92933
92934
92935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92936   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92937   Dali::Vector2 *arg2 = 0 ;
92938
92939   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92940   arg2 = (Dali::Vector2 *)jarg2;
92941   if (!arg2) {
92942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92943     return ;
92944   }
92945   {
92946     try {
92947       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92948     } catch (std::out_of_range& e) {
92949       {
92950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92951       };
92952     } catch (std::exception& e) {
92953       {
92954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92955       };
92956     } catch (Dali::DaliException e) {
92957       {
92958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92959       };
92960     } catch (...) {
92961       {
92962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92963       };
92964     }
92965   }
92966
92967 }
92968
92969
92970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92971   void * jresult ;
92972   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92973
92974   {
92975     try {
92976       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92977     } catch (std::out_of_range& e) {
92978       {
92979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92980       };
92981     } catch (std::exception& e) {
92982       {
92983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92984       };
92985     } catch (Dali::DaliException e) {
92986       {
92987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92988       };
92989     } catch (...) {
92990       {
92991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92992       };
92993     }
92994   }
92995
92996   jresult = (void *)result;
92997   return jresult;
92998 }
92999
93000
93001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
93002   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93003
93004   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93005   {
93006     try {
93007       delete arg1;
93008     } catch (std::out_of_range& e) {
93009       {
93010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93011       };
93012     } catch (std::exception& e) {
93013       {
93014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93015       };
93016     } catch (Dali::DaliException e) {
93017       {
93018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93019       };
93020     } catch (...) {
93021       {
93022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93023       };
93024     }
93025   }
93026
93027 }
93028
93029
93030
93031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
93032   unsigned int jresult ;
93033   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93034   bool result;
93035
93036   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93037   {
93038     try {
93039       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);
93040     } catch (std::out_of_range& e) {
93041       {
93042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (std::exception& e) {
93045       {
93046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (Dali::DaliException e) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93055       };
93056     }
93057   }
93058
93059   jresult = result;
93060   return jresult;
93061 }
93062
93063
93064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
93065   unsigned long jresult ;
93066   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93067   std::size_t result;
93068
93069   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93070   {
93071     try {
93072       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);
93073     } catch (std::out_of_range& e) {
93074       {
93075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93076       };
93077     } catch (std::exception& e) {
93078       {
93079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93080       };
93081     } catch (Dali::DaliException e) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93084       };
93085     } catch (...) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93088       };
93089     }
93090   }
93091
93092   jresult = (unsigned long)result;
93093   return jresult;
93094 }
93095
93096
93097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
93098   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93099   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93100
93101   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93102   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93103   {
93104     try {
93105       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93106     } catch (std::out_of_range& e) {
93107       {
93108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93109       };
93110     } catch (std::exception& e) {
93111       {
93112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93113       };
93114     } catch (Dali::DaliException e) {
93115       {
93116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93117       };
93118     } catch (...) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93121       };
93122     }
93123   }
93124
93125 }
93126
93127
93128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
93129   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93130   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93131
93132   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93133   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93134   {
93135     try {
93136       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93137     } catch (std::out_of_range& e) {
93138       {
93139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93140       };
93141     } catch (std::exception& e) {
93142       {
93143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93144       };
93145     } catch (Dali::DaliException e) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93148       };
93149     } catch (...) {
93150       {
93151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93152       };
93153     }
93154   }
93155
93156 }
93157
93158
93159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93160   unsigned int jresult ;
93161   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93162   Dali::Toolkit::Control arg2 ;
93163   Dali::KeyEvent *arg3 = 0 ;
93164   Dali::Toolkit::Control *argp2 ;
93165   bool result;
93166
93167   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93168   argp2 = (Dali::Toolkit::Control *)jarg2;
93169   if (!argp2) {
93170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93171     return 0;
93172   }
93173   arg2 = *argp2;
93174   arg3 = (Dali::KeyEvent *)jarg3;
93175   if (!arg3) {
93176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93177     return 0;
93178   }
93179   {
93180     try {
93181       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);
93182     } catch (std::out_of_range& e) {
93183       {
93184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93185       };
93186     } catch (std::exception& e) {
93187       {
93188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93189       };
93190     } catch (Dali::DaliException e) {
93191       {
93192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93193       };
93194     } catch (...) {
93195       {
93196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93197       };
93198     }
93199   }
93200
93201   jresult = result;
93202   return jresult;
93203 }
93204
93205
93206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93207   void * jresult ;
93208   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93209
93210   {
93211     try {
93212       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93213     } catch (std::out_of_range& e) {
93214       {
93215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93216       };
93217     } catch (std::exception& e) {
93218       {
93219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93220       };
93221     } catch (Dali::DaliException e) {
93222       {
93223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93224       };
93225     } catch (...) {
93226       {
93227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93228       };
93229     }
93230   }
93231
93232   jresult = (void *)result;
93233   return jresult;
93234 }
93235
93236
93237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93238   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93239
93240   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93241   {
93242     try {
93243       delete arg1;
93244     } catch (std::out_of_range& e) {
93245       {
93246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93247       };
93248     } catch (std::exception& e) {
93249       {
93250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (Dali::DaliException e) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93259       };
93260     }
93261   }
93262
93263 }
93264
93265
93266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93267   unsigned int jresult ;
93268   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93269   bool result;
93270
93271   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93272   {
93273     try {
93274       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93275     } catch (std::out_of_range& e) {
93276       {
93277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93278       };
93279     } catch (std::exception& e) {
93280       {
93281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93282       };
93283     } catch (Dali::DaliException e) {
93284       {
93285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93286       };
93287     } catch (...) {
93288       {
93289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93290       };
93291     }
93292   }
93293
93294   jresult = result;
93295   return jresult;
93296 }
93297
93298
93299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93300   unsigned long jresult ;
93301   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93302   std::size_t result;
93303
93304   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93305   {
93306     try {
93307       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93308     } catch (std::out_of_range& e) {
93309       {
93310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93311       };
93312     } catch (std::exception& e) {
93313       {
93314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93315       };
93316     } catch (Dali::DaliException e) {
93317       {
93318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93319       };
93320     } catch (...) {
93321       {
93322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93323       };
93324     }
93325   }
93326
93327   jresult = (unsigned long)result;
93328   return jresult;
93329 }
93330
93331
93332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93333   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93334   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93335
93336   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93337   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93338   {
93339     try {
93340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93341     } catch (std::out_of_range& e) {
93342       {
93343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93344       };
93345     } catch (std::exception& e) {
93346       {
93347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93348       };
93349     } catch (Dali::DaliException e) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93352       };
93353     } catch (...) {
93354       {
93355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93356       };
93357     }
93358   }
93359
93360 }
93361
93362
93363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93364   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93365   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93366
93367   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93368   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93369   {
93370     try {
93371       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93372     } catch (std::out_of_range& e) {
93373       {
93374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93375       };
93376     } catch (std::exception& e) {
93377       {
93378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93379       };
93380     } catch (Dali::DaliException e) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93383       };
93384     } catch (...) {
93385       {
93386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93387       };
93388     }
93389   }
93390
93391 }
93392
93393
93394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93395   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93396   Dali::Toolkit::Control arg2 ;
93397   Dali::Toolkit::Control *argp2 ;
93398
93399   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93400   argp2 = (Dali::Toolkit::Control *)jarg2;
93401   if (!argp2) {
93402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93403     return ;
93404   }
93405   arg2 = *argp2;
93406   {
93407     try {
93408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93409     } catch (std::out_of_range& e) {
93410       {
93411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93412       };
93413     } catch (std::exception& e) {
93414       {
93415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93416       };
93417     } catch (Dali::DaliException e) {
93418       {
93419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93420       };
93421     } catch (...) {
93422       {
93423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93424       };
93425     }
93426   }
93427
93428 }
93429
93430
93431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93432   void * jresult ;
93433   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93434
93435   {
93436     try {
93437       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93438     } catch (std::out_of_range& e) {
93439       {
93440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93441       };
93442     } catch (std::exception& e) {
93443       {
93444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (Dali::DaliException e) {
93447       {
93448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93449       };
93450     } catch (...) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93453       };
93454     }
93455   }
93456
93457   jresult = (void *)result;
93458   return jresult;
93459 }
93460
93461
93462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93463   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93464
93465   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93466   {
93467     try {
93468       delete arg1;
93469     } catch (std::out_of_range& e) {
93470       {
93471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93472       };
93473     } catch (std::exception& e) {
93474       {
93475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93476       };
93477     } catch (Dali::DaliException e) {
93478       {
93479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93480       };
93481     } catch (...) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93484       };
93485     }
93486   }
93487
93488 }
93489
93490
93491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93492   unsigned int jresult ;
93493   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93494   bool result;
93495
93496   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93497   {
93498     try {
93499       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93500     } catch (std::out_of_range& e) {
93501       {
93502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93503       };
93504     } catch (std::exception& e) {
93505       {
93506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93507       };
93508     } catch (Dali::DaliException e) {
93509       {
93510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93511       };
93512     } catch (...) {
93513       {
93514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93515       };
93516     }
93517   }
93518
93519   jresult = result;
93520   return jresult;
93521 }
93522
93523
93524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93525   unsigned long jresult ;
93526   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93527   std::size_t result;
93528
93529   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93530   {
93531     try {
93532       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93533     } catch (std::out_of_range& e) {
93534       {
93535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93536       };
93537     } catch (std::exception& e) {
93538       {
93539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93540       };
93541     } catch (Dali::DaliException e) {
93542       {
93543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93544       };
93545     } catch (...) {
93546       {
93547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93548       };
93549     }
93550   }
93551
93552   jresult = (unsigned long)result;
93553   return jresult;
93554 }
93555
93556
93557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93558   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93559   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93560
93561   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93562   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93563   {
93564     try {
93565       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93566     } catch (std::out_of_range& e) {
93567       {
93568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93569       };
93570     } catch (std::exception& e) {
93571       {
93572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93573       };
93574     } catch (Dali::DaliException e) {
93575       {
93576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93577       };
93578     } catch (...) {
93579       {
93580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93581       };
93582     }
93583   }
93584
93585 }
93586
93587
93588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93589   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93590   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93591
93592   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93593   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93594   {
93595     try {
93596       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93597     } catch (std::out_of_range& e) {
93598       {
93599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93600       };
93601     } catch (std::exception& e) {
93602       {
93603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93604       };
93605     } catch (Dali::DaliException e) {
93606       {
93607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93608       };
93609     } catch (...) {
93610       {
93611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93612       };
93613     }
93614   }
93615
93616 }
93617
93618
93619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93620   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93621   Dali::Toolkit::VideoView *arg2 = 0 ;
93622
93623   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93624   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93625   if (!arg2) {
93626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93627     return ;
93628   }
93629   {
93630     try {
93631       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93632     } catch (std::out_of_range& e) {
93633       {
93634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93635       };
93636     } catch (std::exception& e) {
93637       {
93638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93639       };
93640     } catch (Dali::DaliException e) {
93641       {
93642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93643       };
93644     } catch (...) {
93645       {
93646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93647       };
93648     }
93649   }
93650
93651 }
93652
93653
93654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93655   void * jresult ;
93656   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93657
93658   {
93659     try {
93660       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93661     } catch (std::out_of_range& e) {
93662       {
93663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93664       };
93665     } catch (std::exception& e) {
93666       {
93667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93668       };
93669     } catch (Dali::DaliException e) {
93670       {
93671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93672       };
93673     } catch (...) {
93674       {
93675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93676       };
93677     }
93678   }
93679
93680   jresult = (void *)result;
93681   return jresult;
93682 }
93683
93684
93685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93686   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93687
93688   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93689   {
93690     try {
93691       delete arg1;
93692     } catch (std::out_of_range& e) {
93693       {
93694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93695       };
93696     } catch (std::exception& e) {
93697       {
93698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93699       };
93700     } catch (Dali::DaliException e) {
93701       {
93702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93703       };
93704     } catch (...) {
93705       {
93706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93707       };
93708     }
93709   }
93710
93711 }
93712
93713
93714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93715   unsigned int jresult ;
93716   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93717   bool result;
93718
93719   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93720   {
93721     try {
93722       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93723     } catch (std::out_of_range& e) {
93724       {
93725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93726       };
93727     } catch (std::exception& e) {
93728       {
93729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93730       };
93731     } catch (Dali::DaliException e) {
93732       {
93733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93734       };
93735     } catch (...) {
93736       {
93737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93738       };
93739     }
93740   }
93741
93742   jresult = result;
93743   return jresult;
93744 }
93745
93746
93747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93748   unsigned long jresult ;
93749   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93750   std::size_t result;
93751
93752   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93753   {
93754     try {
93755       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93756     } catch (std::out_of_range& e) {
93757       {
93758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93759       };
93760     } catch (std::exception& e) {
93761       {
93762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93763       };
93764     } catch (Dali::DaliException e) {
93765       {
93766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93767       };
93768     } catch (...) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93771       };
93772     }
93773   }
93774
93775   jresult = (unsigned long)result;
93776   return jresult;
93777 }
93778
93779
93780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93781   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93782   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93783
93784   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93785   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93786   {
93787     try {
93788       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93789     } catch (std::out_of_range& e) {
93790       {
93791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93792       };
93793     } catch (std::exception& e) {
93794       {
93795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93796       };
93797     } catch (Dali::DaliException e) {
93798       {
93799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93800       };
93801     } catch (...) {
93802       {
93803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93804       };
93805     }
93806   }
93807
93808 }
93809
93810
93811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93812   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93813   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93814
93815   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93816   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93817   {
93818     try {
93819       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93820     } catch (std::out_of_range& e) {
93821       {
93822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93823       };
93824     } catch (std::exception& e) {
93825       {
93826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93827       };
93828     } catch (Dali::DaliException e) {
93829       {
93830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93831       };
93832     } catch (...) {
93833       {
93834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93835       };
93836     }
93837   }
93838
93839 }
93840
93841
93842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93843   unsigned int jresult ;
93844   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93845   Dali::Toolkit::Slider arg2 ;
93846   float arg3 ;
93847   Dali::Toolkit::Slider *argp2 ;
93848   bool result;
93849
93850   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93851   argp2 = (Dali::Toolkit::Slider *)jarg2;
93852   if (!argp2) {
93853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93854     return 0;
93855   }
93856   arg2 = *argp2;
93857   arg3 = (float)jarg3;
93858   {
93859     try {
93860       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93861     } catch (std::out_of_range& e) {
93862       {
93863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93864       };
93865     } catch (std::exception& e) {
93866       {
93867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93868       };
93869     } catch (Dali::DaliException e) {
93870       {
93871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93872       };
93873     } catch (...) {
93874       {
93875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93876       };
93877     }
93878   }
93879
93880   jresult = result;
93881   return jresult;
93882 }
93883
93884
93885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93886   void * jresult ;
93887   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93888
93889   {
93890     try {
93891       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93892     } catch (std::out_of_range& e) {
93893       {
93894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93895       };
93896     } catch (std::exception& e) {
93897       {
93898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93899       };
93900     } catch (Dali::DaliException e) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93903       };
93904     } catch (...) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93907       };
93908     }
93909   }
93910
93911   jresult = (void *)result;
93912   return jresult;
93913 }
93914
93915
93916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93917   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93918
93919   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93920   {
93921     try {
93922       delete arg1;
93923     } catch (std::out_of_range& e) {
93924       {
93925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93926       };
93927     } catch (std::exception& e) {
93928       {
93929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93930       };
93931     } catch (Dali::DaliException e) {
93932       {
93933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93934       };
93935     } catch (...) {
93936       {
93937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93938       };
93939     }
93940   }
93941
93942 }
93943
93944
93945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93946   unsigned int jresult ;
93947   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93948   bool result;
93949
93950   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93951   {
93952     try {
93953       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93954     } catch (std::out_of_range& e) {
93955       {
93956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93957       };
93958     } catch (std::exception& e) {
93959       {
93960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93961       };
93962     } catch (Dali::DaliException e) {
93963       {
93964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93965       };
93966     } catch (...) {
93967       {
93968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93969       };
93970     }
93971   }
93972
93973   jresult = result;
93974   return jresult;
93975 }
93976
93977
93978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93979   unsigned long jresult ;
93980   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93981   std::size_t result;
93982
93983   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93984   {
93985     try {
93986       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93987     } catch (std::out_of_range& e) {
93988       {
93989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93990       };
93991     } catch (std::exception& e) {
93992       {
93993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93994       };
93995     } catch (Dali::DaliException e) {
93996       {
93997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93998       };
93999     } catch (...) {
94000       {
94001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94002       };
94003     }
94004   }
94005
94006   jresult = (unsigned long)result;
94007   return jresult;
94008 }
94009
94010
94011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
94012   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94013   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94014
94015   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94016   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94017   {
94018     try {
94019       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
94020     } catch (std::out_of_range& e) {
94021       {
94022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94023       };
94024     } catch (std::exception& e) {
94025       {
94026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94027       };
94028     } catch (Dali::DaliException e) {
94029       {
94030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94031       };
94032     } catch (...) {
94033       {
94034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94035       };
94036     }
94037   }
94038
94039 }
94040
94041
94042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
94043   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94044   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94045
94046   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94047   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94048   {
94049     try {
94050       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
94051     } catch (std::out_of_range& e) {
94052       {
94053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94054       };
94055     } catch (std::exception& e) {
94056       {
94057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94058       };
94059     } catch (Dali::DaliException e) {
94060       {
94061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94062       };
94063     } catch (...) {
94064       {
94065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94066       };
94067     }
94068   }
94069
94070 }
94071
94072
94073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94074   unsigned int jresult ;
94075   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94076   Dali::Toolkit::Slider arg2 ;
94077   int arg3 ;
94078   Dali::Toolkit::Slider *argp2 ;
94079   bool result;
94080
94081   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94082   argp2 = (Dali::Toolkit::Slider *)jarg2;
94083   if (!argp2) {
94084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
94085     return 0;
94086   }
94087   arg2 = *argp2;
94088   arg3 = (int)jarg3;
94089   {
94090     try {
94091       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
94092     } catch (std::out_of_range& e) {
94093       {
94094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94095       };
94096     } catch (std::exception& e) {
94097       {
94098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94099       };
94100     } catch (Dali::DaliException e) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94103       };
94104     } catch (...) {
94105       {
94106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94107       };
94108     }
94109   }
94110
94111   jresult = result;
94112   return jresult;
94113 }
94114
94115
94116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
94117   void * jresult ;
94118   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
94119
94120   {
94121     try {
94122       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
94123     } catch (std::out_of_range& e) {
94124       {
94125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94126       };
94127     } catch (std::exception& e) {
94128       {
94129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94130       };
94131     } catch (Dali::DaliException e) {
94132       {
94133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94134       };
94135     } catch (...) {
94136       {
94137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94138       };
94139     }
94140   }
94141
94142   jresult = (void *)result;
94143   return jresult;
94144 }
94145
94146
94147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
94148   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94149
94150   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94151   {
94152     try {
94153       delete arg1;
94154     } catch (std::out_of_range& e) {
94155       {
94156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94157       };
94158     } catch (std::exception& e) {
94159       {
94160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94161       };
94162     } catch (Dali::DaliException e) {
94163       {
94164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94165       };
94166     } catch (...) {
94167       {
94168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94169       };
94170     }
94171   }
94172
94173 }
94174
94175
94176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94177   void * jresult ;
94178   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94179
94180   {
94181     try {
94182       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94183     } catch (std::out_of_range& e) {
94184       {
94185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94186       };
94187     } catch (std::exception& e) {
94188       {
94189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94190       };
94191     } catch (Dali::DaliException e) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94194       };
94195     } catch (...) {
94196       {
94197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94198       };
94199     }
94200   }
94201
94202   jresult = (void *)result;
94203   return jresult;
94204 }
94205
94206
94207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94208   void * jresult ;
94209   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94210   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94211
94212   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94213   {
94214     try {
94215       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94216     } catch (std::out_of_range& e) {
94217       {
94218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94219       };
94220     } catch (std::exception& e) {
94221       {
94222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94223       };
94224     } catch (Dali::DaliException e) {
94225       {
94226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94227       };
94228     } catch (...) {
94229       {
94230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94231       };
94232     }
94233   }
94234
94235   jresult = (void *)result;
94236   return jresult;
94237 }
94238
94239
94240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94241   void * jresult ;
94242   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94244
94245   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94246   if (!arg1) {
94247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94248     return 0;
94249   }
94250   {
94251     try {
94252       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94253     } catch (std::out_of_range& e) {
94254       {
94255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94256       };
94257     } catch (std::exception& e) {
94258       {
94259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94260       };
94261     } catch (Dali::DaliException e) {
94262       {
94263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94264       };
94265     } catch (...) {
94266       {
94267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94268       };
94269     }
94270   }
94271
94272   jresult = (void *)result;
94273   return jresult;
94274 }
94275
94276
94277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94278   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94279
94280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94281   {
94282     try {
94283       delete arg1;
94284     } catch (std::out_of_range& e) {
94285       {
94286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94287       };
94288     } catch (std::exception& e) {
94289       {
94290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94291       };
94292     } catch (Dali::DaliException e) {
94293       {
94294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94295       };
94296     } catch (...) {
94297       {
94298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94299       };
94300     }
94301   }
94302
94303 }
94304
94305
94306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94307   void * jresult ;
94308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94309   Dali::Toolkit::Ruler *result = 0 ;
94310
94311   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94312   {
94313     try {
94314       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94315     } catch (std::out_of_range& e) {
94316       {
94317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94318       };
94319     } catch (std::exception& e) {
94320       {
94321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94322       };
94323     } catch (Dali::DaliException e) {
94324       {
94325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94326       };
94327     } catch (...) {
94328       {
94329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94330       };
94331     }
94332   }
94333
94334   jresult = (void *)result;
94335   return jresult;
94336 }
94337
94338
94339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94340   void * jresult ;
94341   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94342   Dali::Toolkit::Ruler *result = 0 ;
94343
94344   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94345   {
94346     try {
94347       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94348     } catch (std::out_of_range& e) {
94349       {
94350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94351       };
94352     } catch (std::exception& e) {
94353       {
94354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94355       };
94356     } catch (Dali::DaliException e) {
94357       {
94358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94359       };
94360     } catch (...) {
94361       {
94362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94363       };
94364     }
94365   }
94366
94367   jresult = (void *)result;
94368   return jresult;
94369 }
94370
94371
94372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94373   void * jresult ;
94374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94375   Dali::Toolkit::Ruler *result = 0 ;
94376
94377   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94378   {
94379     try {
94380       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94381     } catch (std::out_of_range& e) {
94382       {
94383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94384       };
94385     } catch (std::exception& e) {
94386       {
94387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94388       };
94389     } catch (Dali::DaliException e) {
94390       {
94391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94392       };
94393     } catch (...) {
94394       {
94395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94396       };
94397     }
94398   }
94399
94400   jresult = (void *)result;
94401   return jresult;
94402 }
94403
94404
94405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94406   void * jresult ;
94407   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94408   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94409   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94410
94411   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94412   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94413   if (!arg2) {
94414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94415     return 0;
94416   }
94417   {
94418     try {
94419       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94420     } catch (std::out_of_range& e) {
94421       {
94422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94423       };
94424     } catch (std::exception& e) {
94425       {
94426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94427       };
94428     } catch (Dali::DaliException e) {
94429       {
94430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94431       };
94432     } catch (...) {
94433       {
94434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94435       };
94436     }
94437   }
94438
94439   jresult = (void *)result;
94440   return jresult;
94441 }
94442
94443
94444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94445   void * jresult ;
94446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94447   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94448   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94449
94450   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94451   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94452   {
94453     try {
94454       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94455     } catch (std::out_of_range& e) {
94456       {
94457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94458       };
94459     } catch (std::exception& e) {
94460       {
94461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94462       };
94463     } catch (Dali::DaliException e) {
94464       {
94465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94466       };
94467     } catch (...) {
94468       {
94469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94470       };
94471     }
94472   }
94473
94474   jresult = (void *)result;
94475   return jresult;
94476 }
94477
94478
94479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94480   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94481
94482   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94483   {
94484     try {
94485       (arg1)->Reset();
94486     } catch (std::out_of_range& e) {
94487       {
94488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94489       };
94490     } catch (std::exception& e) {
94491       {
94492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94493       };
94494     } catch (Dali::DaliException e) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94497       };
94498     } catch (...) {
94499       {
94500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94501       };
94502     }
94503   }
94504
94505 }
94506
94507
94508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94509   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94510   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94511
94512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94513   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94514   {
94515     try {
94516       (arg1)->Reset(arg2);
94517     } catch (std::out_of_range& e) {
94518       {
94519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94520       };
94521     } catch (std::exception& e) {
94522       {
94523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94524       };
94525     } catch (Dali::DaliException e) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94528       };
94529     } catch (...) {
94530       {
94531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94532       };
94533     }
94534   }
94535
94536 }
94537
94538
94539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94540   void * jresult ;
94541   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94542   Dali::Toolkit::Ruler *result = 0 ;
94543
94544   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94545   {
94546     try {
94547       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94548     } catch (std::out_of_range& e) {
94549       {
94550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94551       };
94552     } catch (std::exception& e) {
94553       {
94554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94555       };
94556     } catch (Dali::DaliException e) {
94557       {
94558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94559       };
94560     } catch (...) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94563       };
94564     }
94565   }
94566
94567   jresult = (void *)result;
94568   return jresult;
94569 }
94570
94571
94572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94573   float jresult ;
94574   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94575   float arg2 ;
94576   float arg3 ;
94577   float result;
94578
94579   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94580   arg2 = (float)jarg2;
94581   arg3 = (float)jarg3;
94582   {
94583     try {
94584       result = (float)(*arg1)->Snap(arg2,arg3);
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94600       };
94601     }
94602   }
94603
94604   jresult = result;
94605   return jresult;
94606 }
94607
94608
94609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94610   float jresult ;
94611   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94612   float arg2 ;
94613   float result;
94614
94615   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94616   arg2 = (float)jarg2;
94617   {
94618     try {
94619       result = (float)(*arg1)->Snap(arg2);
94620     } catch (std::out_of_range& e) {
94621       {
94622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94623       };
94624     } catch (std::exception& e) {
94625       {
94626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94627       };
94628     } catch (Dali::DaliException e) {
94629       {
94630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94631       };
94632     } catch (...) {
94633       {
94634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94635       };
94636     }
94637   }
94638
94639   jresult = result;
94640   return jresult;
94641 }
94642
94643
94644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94645   float jresult ;
94646   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94647   unsigned int arg2 ;
94648   unsigned int *arg3 = 0 ;
94649   bool arg4 ;
94650   float result;
94651
94652   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94653   arg2 = (unsigned int)jarg2;
94654   arg3 = (unsigned int *)jarg3;
94655   arg4 = jarg4 ? true : false;
94656   {
94657     try {
94658       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94659     } catch (std::out_of_range& e) {
94660       {
94661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94662       };
94663     } catch (std::exception& e) {
94664       {
94665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94666       };
94667     } catch (Dali::DaliException e) {
94668       {
94669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94670       };
94671     } catch (...) {
94672       {
94673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94674       };
94675     }
94676   }
94677
94678   jresult = result;
94679   return jresult;
94680 }
94681
94682
94683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94684   unsigned int jresult ;
94685   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94686   float arg2 ;
94687   bool arg3 ;
94688   unsigned int result;
94689
94690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94691   arg2 = (float)jarg2;
94692   arg3 = jarg3 ? true : false;
94693   {
94694     try {
94695       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94696     } catch (std::out_of_range& e) {
94697       {
94698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94699       };
94700     } catch (std::exception& e) {
94701       {
94702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94703       };
94704     } catch (Dali::DaliException e) {
94705       {
94706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94707       };
94708     } catch (...) {
94709       {
94710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94711       };
94712     }
94713   }
94714
94715   jresult = result;
94716   return jresult;
94717 }
94718
94719
94720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94721   unsigned int jresult ;
94722   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94723   unsigned int result;
94724
94725   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94726   {
94727     try {
94728       result = (unsigned int)(*arg1)->GetTotalPages();
94729     } catch (std::out_of_range& e) {
94730       {
94731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94732       };
94733     } catch (std::exception& e) {
94734       {
94735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94736       };
94737     } catch (Dali::DaliException e) {
94738       {
94739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94740       };
94741     } catch (...) {
94742       {
94743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94744       };
94745     }
94746   }
94747
94748   jresult = result;
94749   return jresult;
94750 }
94751
94752
94753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94754   int jresult ;
94755   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94756   Dali::Toolkit::Ruler::RulerType result;
94757
94758   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94759   {
94760     try {
94761       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94762     } catch (std::out_of_range& e) {
94763       {
94764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94765       };
94766     } catch (std::exception& e) {
94767       {
94768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94769       };
94770     } catch (Dali::DaliException e) {
94771       {
94772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94773       };
94774     } catch (...) {
94775       {
94776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94777       };
94778     }
94779   }
94780
94781   jresult = (int)result;
94782   return jresult;
94783 }
94784
94785
94786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94787   unsigned int jresult ;
94788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94789   bool result;
94790
94791   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94792   {
94793     try {
94794       result = (bool)(*arg1)->IsEnabled();
94795     } catch (std::out_of_range& e) {
94796       {
94797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94798       };
94799     } catch (std::exception& e) {
94800       {
94801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94802       };
94803     } catch (Dali::DaliException e) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94806       };
94807     } catch (...) {
94808       {
94809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94810       };
94811     }
94812   }
94813
94814   jresult = result;
94815   return jresult;
94816 }
94817
94818
94819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94820   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94821
94822   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94823   {
94824     try {
94825       (*arg1)->Enable();
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94841       };
94842     }
94843   }
94844
94845 }
94846
94847
94848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94850
94851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94852   {
94853     try {
94854       (*arg1)->Disable();
94855     } catch (std::out_of_range& e) {
94856       {
94857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94858       };
94859     } catch (std::exception& e) {
94860       {
94861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94862       };
94863     } catch (Dali::DaliException e) {
94864       {
94865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94866       };
94867     } catch (...) {
94868       {
94869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94870       };
94871     }
94872   }
94873
94874 }
94875
94876
94877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94878   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94879   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94880   Dali::Toolkit::RulerDomain *argp2 ;
94881
94882   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94883   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94884   if (!argp2) {
94885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94886     return ;
94887   }
94888   arg2 = *argp2;
94889   {
94890     try {
94891       (*arg1)->SetDomain(arg2);
94892     } catch (std::out_of_range& e) {
94893       {
94894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (std::exception& e) {
94897       {
94898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94899       };
94900     } catch (Dali::DaliException e) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94903       };
94904     } catch (...) {
94905       {
94906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94907       };
94908     }
94909   }
94910
94911 }
94912
94913
94914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94915   void * jresult ;
94916   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94917   Dali::Toolkit::RulerDomain *result = 0 ;
94918
94919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94920   {
94921     try {
94922       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94923     } catch (std::out_of_range& e) {
94924       {
94925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94926       };
94927     } catch (std::exception& e) {
94928       {
94929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94930       };
94931     } catch (Dali::DaliException e) {
94932       {
94933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94934       };
94935     } catch (...) {
94936       {
94937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94938       };
94939     }
94940   }
94941
94942   jresult = (void *)result;
94943   return jresult;
94944 }
94945
94946
94947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94948   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94949
94950   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94951   {
94952     try {
94953       (*arg1)->DisableDomain();
94954     } catch (std::out_of_range& e) {
94955       {
94956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94957       };
94958     } catch (std::exception& e) {
94959       {
94960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94961       };
94962     } catch (Dali::DaliException e) {
94963       {
94964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94965       };
94966     } catch (...) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94969       };
94970     }
94971   }
94972
94973 }
94974
94975
94976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94977   float jresult ;
94978   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94979   float arg2 ;
94980   float arg3 ;
94981   float arg4 ;
94982   float result;
94983
94984   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94985   arg2 = (float)jarg2;
94986   arg3 = (float)jarg3;
94987   arg4 = (float)jarg4;
94988   {
94989     try {
94990       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94991     } catch (std::out_of_range& e) {
94992       {
94993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94994       };
94995     } catch (std::exception& e) {
94996       {
94997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94998       };
94999     } catch (Dali::DaliException e) {
95000       {
95001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95002       };
95003     } catch (...) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95006       };
95007     }
95008   }
95009
95010   jresult = result;
95011   return jresult;
95012 }
95013
95014
95015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
95016   float jresult ;
95017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95018   float arg2 ;
95019   float arg3 ;
95020   float result;
95021
95022   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95023   arg2 = (float)jarg2;
95024   arg3 = (float)jarg3;
95025   {
95026     try {
95027       result = (float)(*arg1)->Clamp(arg2,arg3);
95028     } catch (std::out_of_range& e) {
95029       {
95030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95031       };
95032     } catch (std::exception& e) {
95033       {
95034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95035       };
95036     } catch (Dali::DaliException e) {
95037       {
95038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95039       };
95040     } catch (...) {
95041       {
95042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95043       };
95044     }
95045   }
95046
95047   jresult = result;
95048   return jresult;
95049 }
95050
95051
95052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
95053   float jresult ;
95054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95055   float arg2 ;
95056   float result;
95057
95058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95059   arg2 = (float)jarg2;
95060   {
95061     try {
95062       result = (float)(*arg1)->Clamp(arg2);
95063     } catch (std::out_of_range& e) {
95064       {
95065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95066       };
95067     } catch (std::exception& e) {
95068       {
95069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95070       };
95071     } catch (Dali::DaliException e) {
95072       {
95073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95074       };
95075     } catch (...) {
95076       {
95077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95078       };
95079     }
95080   }
95081
95082   jresult = result;
95083   return jresult;
95084 }
95085
95086
95087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
95088   float jresult ;
95089   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95090   float arg2 ;
95091   float arg3 ;
95092   float arg4 ;
95093   Dali::Toolkit::ClampState *arg5 = 0 ;
95094   float result;
95095
95096   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95097   arg2 = (float)jarg2;
95098   arg3 = (float)jarg3;
95099   arg4 = (float)jarg4;
95100   arg5 = (Dali::Toolkit::ClampState *)jarg5;
95101   if (!arg5) {
95102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95103     return 0;
95104   }
95105   {
95106     try {
95107       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
95108     } catch (std::out_of_range& e) {
95109       {
95110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95111       };
95112     } catch (std::exception& e) {
95113       {
95114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95115       };
95116     } catch (Dali::DaliException e) {
95117       {
95118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95119       };
95120     } catch (...) {
95121       {
95122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95123       };
95124     }
95125   }
95126
95127   jresult = result;
95128   return jresult;
95129 }
95130
95131
95132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
95133   float jresult ;
95134   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95135   float arg2 ;
95136   float arg3 ;
95137   float arg4 ;
95138   float arg5 ;
95139   float result;
95140
95141   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95142   arg2 = (float)jarg2;
95143   arg3 = (float)jarg3;
95144   arg4 = (float)jarg4;
95145   arg5 = (float)jarg5;
95146   {
95147     try {
95148       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
95149     } catch (std::out_of_range& e) {
95150       {
95151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95152       };
95153     } catch (std::exception& e) {
95154       {
95155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95156       };
95157     } catch (Dali::DaliException e) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95160       };
95161     } catch (...) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95164       };
95165     }
95166   }
95167
95168   jresult = result;
95169   return jresult;
95170 }
95171
95172
95173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
95174   float jresult ;
95175   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95176   float arg2 ;
95177   float arg3 ;
95178   float arg4 ;
95179   float result;
95180
95181   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95182   arg2 = (float)jarg2;
95183   arg3 = (float)jarg3;
95184   arg4 = (float)jarg4;
95185   {
95186     try {
95187       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95188     } catch (std::out_of_range& e) {
95189       {
95190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95191       };
95192     } catch (std::exception& e) {
95193       {
95194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95195       };
95196     } catch (Dali::DaliException e) {
95197       {
95198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95199       };
95200     } catch (...) {
95201       {
95202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95203       };
95204     }
95205   }
95206
95207   jresult = result;
95208   return jresult;
95209 }
95210
95211
95212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95213   float jresult ;
95214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95215   float arg2 ;
95216   float arg3 ;
95217   float result;
95218
95219   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95220   arg2 = (float)jarg2;
95221   arg3 = (float)jarg3;
95222   {
95223     try {
95224       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95225     } catch (std::out_of_range& e) {
95226       {
95227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95228       };
95229     } catch (std::exception& e) {
95230       {
95231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95232       };
95233     } catch (Dali::DaliException e) {
95234       {
95235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95236       };
95237     } catch (...) {
95238       {
95239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95240       };
95241     }
95242   }
95243
95244   jresult = result;
95245   return jresult;
95246 }
95247
95248
95249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95250   float jresult ;
95251   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95252   float arg2 ;
95253   float result;
95254
95255   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95256   arg2 = (float)jarg2;
95257   {
95258     try {
95259       result = (float)(*arg1)->SnapAndClamp(arg2);
95260     } catch (std::out_of_range& e) {
95261       {
95262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95263       };
95264     } catch (std::exception& e) {
95265       {
95266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95267       };
95268     } catch (Dali::DaliException e) {
95269       {
95270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95271       };
95272     } catch (...) {
95273       {
95274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95275       };
95276     }
95277   }
95278
95279   jresult = result;
95280   return jresult;
95281 }
95282
95283
95284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95285   float jresult ;
95286   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95287   float arg2 ;
95288   float arg3 ;
95289   float arg4 ;
95290   float arg5 ;
95291   Dali::Toolkit::ClampState *arg6 = 0 ;
95292   float result;
95293
95294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95295   arg2 = (float)jarg2;
95296   arg3 = (float)jarg3;
95297   arg4 = (float)jarg4;
95298   arg5 = (float)jarg5;
95299   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95300   if (!arg6) {
95301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95302     return 0;
95303   }
95304   {
95305     try {
95306       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95307     } catch (std::out_of_range& e) {
95308       {
95309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95310       };
95311     } catch (std::exception& e) {
95312       {
95313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95314       };
95315     } catch (Dali::DaliException e) {
95316       {
95317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95318       };
95319     } catch (...) {
95320       {
95321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95322       };
95323     }
95324   }
95325
95326   jresult = result;
95327   return jresult;
95328 }
95329
95330
95331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95333
95334   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95335   {
95336     try {
95337       (*arg1)->Reference();
95338     } catch (std::out_of_range& e) {
95339       {
95340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95341       };
95342     } catch (std::exception& e) {
95343       {
95344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95345       };
95346     } catch (Dali::DaliException e) {
95347       {
95348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95349       };
95350     } catch (...) {
95351       {
95352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95353       };
95354     }
95355   }
95356
95357 }
95358
95359
95360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95362
95363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95364   {
95365     try {
95366       (*arg1)->Unreference();
95367     } catch (std::out_of_range& e) {
95368       {
95369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95370       };
95371     } catch (std::exception& e) {
95372       {
95373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95374       };
95375     } catch (Dali::DaliException e) {
95376       {
95377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95378       };
95379     } catch (...) {
95380       {
95381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95382       };
95383     }
95384   }
95385
95386 }
95387
95388
95389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95390   int jresult ;
95391   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95392   int result;
95393
95394   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95395   {
95396     try {
95397       result = (int)(*arg1)->ReferenceCount();
95398     } catch (std::out_of_range& e) {
95399       {
95400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95401       };
95402     } catch (std::exception& e) {
95403       {
95404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95405       };
95406     } catch (Dali::DaliException e) {
95407       {
95408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95409       };
95410     } catch (...) {
95411       {
95412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95413       };
95414     }
95415   }
95416
95417   jresult = result;
95418   return jresult;
95419 }
95420
95421
95422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95423   unsigned int jresult ;
95424   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95425   bool result;
95426
95427   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95428   {
95429     try {
95430       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95431     } catch (std::out_of_range& e) {
95432       {
95433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95434       };
95435     } catch (std::exception& e) {
95436       {
95437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95438       };
95439     } catch (Dali::DaliException e) {
95440       {
95441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95442       };
95443     } catch (...) {
95444       {
95445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95446       };
95447     }
95448   }
95449
95450   jresult = result;
95451   return jresult;
95452 }
95453
95454
95455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95456   unsigned long jresult ;
95457   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95458   std::size_t result;
95459
95460   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95461   {
95462     try {
95463       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95464     } catch (std::out_of_range& e) {
95465       {
95466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95467       };
95468     } catch (std::exception& e) {
95469       {
95470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95471       };
95472     } catch (Dali::DaliException e) {
95473       {
95474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95475       };
95476     } catch (...) {
95477       {
95478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95479       };
95480     }
95481   }
95482
95483   jresult = (unsigned long)result;
95484   return jresult;
95485 }
95486
95487
95488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95489   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95490   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95491
95492   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95493   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95494   {
95495     try {
95496       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95497     } catch (std::out_of_range& e) {
95498       {
95499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95500       };
95501     } catch (std::exception& e) {
95502       {
95503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95504       };
95505     } catch (Dali::DaliException e) {
95506       {
95507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95508       };
95509     } catch (...) {
95510       {
95511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95512       };
95513     }
95514   }
95515
95516 }
95517
95518
95519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95520   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95521   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95522
95523   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95524   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95525   {
95526     try {
95527       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95528     } catch (std::out_of_range& e) {
95529       {
95530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95531       };
95532     } catch (std::exception& e) {
95533       {
95534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95535       };
95536     } catch (Dali::DaliException e) {
95537       {
95538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95539       };
95540     } catch (...) {
95541       {
95542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95543       };
95544     }
95545   }
95546
95547 }
95548
95549
95550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95551   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95552   Dali::Toolkit::Control arg2 ;
95553   Dali::Toolkit::Control *argp2 ;
95554
95555   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95556   argp2 = (Dali::Toolkit::Control *)jarg2;
95557   if (!argp2) {
95558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95559     return ;
95560   }
95561   arg2 = *argp2;
95562   {
95563     try {
95564       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95565     } catch (std::out_of_range& e) {
95566       {
95567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95568       };
95569     } catch (std::exception& e) {
95570       {
95571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95572       };
95573     } catch (Dali::DaliException e) {
95574       {
95575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95576       };
95577     } catch (...) {
95578       {
95579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95580       };
95581     }
95582   }
95583
95584 }
95585
95586
95587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95588   void * jresult ;
95589   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95590
95591   {
95592     try {
95593       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95594     } catch (std::out_of_range& e) {
95595       {
95596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95597       };
95598     } catch (std::exception& e) {
95599       {
95600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95601       };
95602     } catch (Dali::DaliException e) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95605       };
95606     } catch (...) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95609       };
95610     }
95611   }
95612
95613   jresult = (void *)result;
95614   return jresult;
95615 }
95616
95617
95618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95619   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95620
95621   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95622   {
95623     try {
95624       delete arg1;
95625     } catch (std::out_of_range& e) {
95626       {
95627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95628       };
95629     } catch (std::exception& e) {
95630       {
95631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95632       };
95633     } catch (Dali::DaliException e) {
95634       {
95635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95636       };
95637     } catch (...) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95640       };
95641     }
95642   }
95643
95644 }
95645
95646 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95647   Dali::RefObject *result = NULL;
95648
95649   if (arg1)
95650   {
95651     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95652   }
95653   return result;
95654 }
95655
95656 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95657     return (Dali::RefObject *)jarg1;
95658 }
95659
95660 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95661     return (Dali::SignalObserver *)jarg1;
95662 }
95663
95664 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95665     return (Dali::ConnectionTrackerInterface *)jarg1;
95666 }
95667
95668 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95669     return (Dali::BaseHandle *)jarg1;
95670 }
95671
95672 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95673     return (Dali::BaseHandle *)jarg1;
95674 }
95675
95676 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95677     return (Dali::BaseHandle *)jarg1;
95678 }
95679
95680 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95681     return (Dali::BaseHandle *)jarg1;
95682 }
95683
95684 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95685     return (Dali::BaseHandle *)jarg1;
95686 }
95687
95688 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95689     return (Dali::BaseHandle *)jarg1;
95690 }
95691
95692 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95693     return (Dali::BaseHandle *)jarg1;
95694 }
95695
95696 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95697     return (Dali::BaseHandle *)jarg1;
95698 }
95699
95700 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95701     return (Dali::BaseHandle *)jarg1;
95702 }
95703
95704 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95705     return (Dali::BaseHandle *)jarg1;
95706 }
95707
95708 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
95709     return (Dali::BaseHandle *)jarg1;
95710 }
95711
95712 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95713     return (Dali::BaseHandle *)jarg1;
95714 }
95715
95716 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95717     return (Dali::Handle *)jarg1;
95718 }
95719
95720 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95721     return (Dali::Handle *)jarg1;
95722 }
95723
95724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95725     return (Dali::BaseHandle *)jarg1;
95726 }
95727
95728 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95729     return (Dali::BaseHandle *)jarg1;
95730 }
95731
95732 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95733     return (Dali::Handle *)jarg1;
95734 }
95735
95736 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95737     return (Dali::BaseHandle *)jarg1;
95738 }
95739
95740 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95741     return (Dali::BaseHandle *)jarg1;
95742 }
95743
95744 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
95745     return (Dali::BaseHandle *)jarg1;
95746 }
95747
95748 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
95749     return (Dali::BaseHandle *)jarg1;
95750 }
95751
95752 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95753     return (Dali::Handle *)jarg1;
95754 }
95755
95756 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95757     return (Dali::GestureDetector *)jarg1;
95758 }
95759
95760 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95761     return (Dali::Gesture *)jarg1;
95762 }
95763
95764 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95765     return (Dali::Handle *)jarg1;
95766 }
95767
95768 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95769     return (Dali::Actor *)jarg1;
95770 }
95771
95772 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95773     return (Dali::RefObject *)jarg1;
95774 }
95775
95776 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95777     return (Dali::Actor *)jarg1;
95778 }
95779
95780 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95781     return (Dali::GestureDetector *)jarg1;
95782 }
95783
95784 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95785     return (Dali::Gesture *)jarg1;
95786 }
95787
95788 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95789     return (Dali::GestureDetector *)jarg1;
95790 }
95791
95792 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95793     return (Dali::Gesture *)jarg1;
95794 }
95795
95796 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95797     return (Dali::GestureDetector *)jarg1;
95798 }
95799
95800 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95801     return (Dali::Gesture *)jarg1;
95802 }
95803
95804 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95805     return (Dali::BaseHandle *)jarg1;
95806 }
95807
95808 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95809     return (Dali::Handle *)jarg1;
95810 }
95811
95812 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95813     return (Dali::Handle *)jarg1;
95814 }
95815
95816 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95817     return (Dali::Handle *)jarg1;
95818 }
95819
95820 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95821     return (Dali::RefObject *)jarg1;
95822 }
95823
95824 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95825     return (Dali::Actor *)jarg1;
95826 }
95827
95828 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95829     return (Dali::BaseHandle *)jarg1;
95830 }
95831
95832 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95833     return (Dali::BaseHandle *)jarg1;
95834 }
95835
95836 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95837     return (Dali::BaseHandle *)jarg1;
95838 }
95839
95840 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95841     return (Dali::CustomActorImpl *)jarg1;
95842 }
95843
95844 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95845     return (Dali::CustomActor *)jarg1;
95846 }
95847
95848 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95849     return (Dali::BaseHandle *)jarg1;
95850 }
95851
95852 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95853     return (Dali::Toolkit::Control *)jarg1;
95854 }
95855
95856 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95857     return (Dali::Toolkit::Control *)jarg1;
95858 }
95859
95860 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95861     return (Dali::Toolkit::Button *)jarg1;
95862 }
95863
95864 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95865     return (Dali::Toolkit::Button *)jarg1;
95866 }
95867
95868 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95869     return (Dali::Toolkit::Button *)jarg1;
95870 }
95871
95872 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95873     return (Dali::Toolkit::Control *)jarg1;
95874 }
95875
95876 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95877     return (Dali::Toolkit::Control *)jarg1;
95878 }
95879
95880 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95881     return (Dali::Toolkit::Control *)jarg1;
95882 }
95883
95884 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95885     return (Dali::Toolkit::Control *)jarg1;
95886 }
95887
95888 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95889     return (Dali::Toolkit::Control *)jarg1;
95890 }
95891
95892 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95893     return (Dali::RefObject *)jarg1;
95894 }
95895
95896 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95897     return (Dali::Toolkit::Scrollable *)jarg1;
95898 }
95899
95900 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95901     return (Dali::BaseHandle *)jarg1;
95902 }
95903
95904 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95905     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95906 }
95907
95908 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95909     return (Dali::RefObject *)jarg1;
95910 }
95911
95912 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95913     return (Dali::Toolkit::Ruler *)jarg1;
95914 }
95915
95916 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95917     return (Dali::Toolkit::Ruler *)jarg1;
95918 }
95919
95920 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95921     return (Dali::Toolkit::Scrollable *)jarg1;
95922 }
95923
95924 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95925     return (Dali::Toolkit::Control *)jarg1;
95926 }
95927
95928
95929 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95930     return (Dali::Toolkit::Control *)jarg1;
95931 }
95932
95933 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95934     return (Dali::BaseHandle *)jarg1;
95935 }
95936
95937 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95938     return (Dali::BaseHandle *)jarg1;
95939 }
95940
95941 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95942     return (Dali::Toolkit::Control *)jarg1;
95943 }
95944
95945 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95946     return (Dali::Toolkit::Control *)jarg1;
95947 }
95948
95949 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95950     return (Dali::Toolkit::Control *)jarg1;
95951 }
95952
95953 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95954     return (Dali::Toolkit::Control *)jarg1;
95955 }
95956
95957 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95958     return (Dali::Toolkit::Control *)jarg1;
95959 }
95960
95961 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95962     return (Dali::Toolkit::Control *)jarg1;
95963 }
95964
95965 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95966     return (Dali::Toolkit::PageTurnView *)jarg1;
95967 }
95968
95969 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95970     return (Dali::Toolkit::PageTurnView *)jarg1;
95971 }
95972
95973 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95974     return (Dali::Toolkit::Button *)jarg1;
95975 }
95976
95977 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95978     return (Dali::BaseHandle *)jarg1;
95979 }
95980
95981 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95982     return (Dali::BaseHandle *)jarg1;
95983 }
95984
95985 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95986     return (Dali::BaseHandle *)jarg1;
95987 }
95988
95989 /*
95990  * Widget binding
95991  */
95992 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95993     return (Dali::BaseHandle *)jarg1;
95994 }
95995
95996 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95997     return (Dali::BaseObject *)jarg1;
95998 }
95999
96000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
96001   void * jresult ;
96002   Dali::Widget result;
96003
96004   {
96005     try {
96006       result = Dali::Widget::New();
96007     } catch (std::out_of_range& e) {
96008       {
96009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96010       };
96011     } catch (std::exception& e) {
96012       {
96013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96014       };
96015     } catch (...) {
96016       {
96017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96018       };
96019     }
96020   }
96021   jresult = new Dali::Widget((const Dali::Widget &)result);
96022   return jresult;
96023 }
96024
96025
96026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
96027   void * jresult ;
96028   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
96029   Dali::Widget result;
96030
96031   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96032
96033   if (!arg1) {
96034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
96035     return 0;
96036   }
96037   {
96038     try {
96039       jresult = new Dali::Widget(arg1);
96040     } catch (std::out_of_range& e) {
96041       {
96042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96043       };
96044     } catch (std::exception& e) {
96045       {
96046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96047       };
96048     } catch (...) {
96049       {
96050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96051       };
96052     }
96053   }
96054   return jresult;
96055 }
96056
96057
96058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
96059   void * jresult ;
96060   Dali::Widget *result = 0 ;
96061
96062   {
96063     try {
96064       result = (Dali::Widget *)new Dali::Widget();
96065     } catch (std::out_of_range& e) {
96066       {
96067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96068       };
96069     } catch (std::exception& e) {
96070       {
96071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96072       };
96073     } catch (...) {
96074       {
96075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96076       };
96077     }
96078   }
96079   jresult = (void *)result;
96080   return jresult;
96081 }
96082
96083
96084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
96085   void * jresult ;
96086   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96087   Dali::Widget *arg2 = 0 ;
96088   Dali::Widget *result = 0 ;
96089
96090   arg1 = (Dali::Widget *)jarg1;
96091   arg2 = (Dali::Widget *)jarg2;
96092   if (!arg2) {
96093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
96094     return 0;
96095   }
96096   {
96097     try {
96098       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
96099     } catch (std::out_of_range& e) {
96100       {
96101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96102       };
96103     } catch (std::exception& e) {
96104       {
96105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96106       };
96107     } catch (...) {
96108       {
96109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96110       };
96111     }
96112   }
96113   jresult = (void *)result;
96114   return jresult;
96115 }
96116
96117
96118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
96119   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96120
96121   arg1 = (Dali::Widget *)jarg1;
96122   {
96123     try {
96124       delete arg1;
96125     } catch (std::out_of_range& e) {
96126       {
96127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96128       };
96129     } catch (std::exception& e) {
96130       {
96131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96132       };
96133     } catch (...) {
96134       {
96135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96136       };
96137     }
96138   }
96139 }
96140
96141
96142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
96143   void * jresult ;
96144   SwigDirector_WidgetImpl* result;
96145   {
96146     try {
96147       result = new SwigDirector_WidgetImpl();
96148     } catch (std::out_of_range& e) {
96149       {
96150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96151       };
96152     } catch (std::exception& e) {
96153       {
96154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96155       };
96156     } catch (...) {
96157       {
96158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96159       };
96160     }
96161   }
96162   jresult = result;
96163   return jresult;
96164 }
96165
96166
96167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
96168   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96169   std::string *arg2 = 0 ;
96170   Dali::Window arg3 ;
96171   Dali::Window *argp3 ;
96172
96173   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96174   if (!jarg2) {
96175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96176     return ;
96177   }
96178   std::string arg2_str(jarg2);
96179   arg2 = &arg2_str;
96180   argp3 = (Dali::Window *)jarg3;
96181   if (!argp3) {
96182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96183     return ;
96184   }
96185   arg3 = *argp3;
96186   {
96187     try {
96188       (arg1)->OnCreate((std::string const &)*arg2,arg3);
96189     } catch (std::out_of_range& e) {
96190       {
96191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (std::exception& e) {
96194       {
96195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (...) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96200       };
96201     }
96202   }
96203 }
96204
96205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96206   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96207   std::string *arg2 = 0 ;
96208   Dali::Window arg3 ;
96209   Dali::Window *argp3 ;
96210
96211   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96212   if (!jarg2) {
96213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96214     return ;
96215   }
96216   std::string arg2_str(jarg2);
96217   arg2 = &arg2_str;
96218   argp3 = (Dali::Window *)jarg3;
96219   if (!argp3) {
96220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96221     return ;
96222   }
96223   arg3 = *argp3;
96224   {
96225     try {
96226       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96227     } catch (std::out_of_range& e) {
96228       {
96229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96230       };
96231     } catch (std::exception& e) {
96232       {
96233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96234       };
96235     } catch (...) {
96236       {
96237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96238       };
96239     }
96240   }
96241 }
96242
96243
96244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96245   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96246   std::string *arg2 = 0 ;
96247   Dali::Widget::Termination arg3 ;
96248
96249   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96250   if (!jarg2) {
96251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96252     return ;
96253   }
96254   std::string arg2_str(jarg2);
96255   arg2 = &arg2_str;
96256   arg3 = (Dali::Widget::Termination)jarg3;
96257   {
96258     try {
96259       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96260     } catch (std::out_of_range& e) {
96261       {
96262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96263       };
96264     } catch (std::exception& e) {
96265       {
96266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96267       };
96268     } catch (...) {
96269       {
96270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96271       };
96272     }
96273   }
96274 }
96275
96276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96277   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96278   std::string *arg2 = 0 ;
96279   Dali::Widget::Termination arg3 ;
96280
96281   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96282   if (!jarg2) {
96283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96284     return ;
96285   }
96286   std::string arg2_str(jarg2);
96287   arg2 = &arg2_str;
96288   arg3 = (Dali::Widget::Termination)jarg3;
96289   {
96290     try {
96291       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96292     } catch (std::out_of_range& e) {
96293       {
96294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96295       };
96296     } catch (std::exception& e) {
96297       {
96298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96299       };
96300     } catch (...) {
96301       {
96302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96303       };
96304     }
96305   }
96306 }
96307
96308
96309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96310   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96311
96312   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96313   {
96314     try {
96315       (arg1)->OnPause();
96316     } catch (std::out_of_range& e) {
96317       {
96318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96319       };
96320     } catch (std::exception& e) {
96321       {
96322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96323       };
96324     } catch (...) {
96325       {
96326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96327       };
96328     }
96329   }
96330 }
96331
96332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96333   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96334
96335   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96336   {
96337     try {
96338       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96339     } catch (std::out_of_range& e) {
96340       {
96341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96342       };
96343     } catch (std::exception& e) {
96344       {
96345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96346       };
96347     } catch (...) {
96348       {
96349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96350       };
96351     }
96352   }
96353 }
96354
96355
96356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96357   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96358
96359   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96360   {
96361     try {
96362       (arg1)->OnResume();
96363     } catch (std::out_of_range& e) {
96364       {
96365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96366       };
96367     } catch (std::exception& e) {
96368       {
96369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96370       };
96371     } catch (...) {
96372       {
96373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96374       };
96375     }
96376   }
96377 }
96378
96379
96380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96381   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96382
96383   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96384   {
96385     try {
96386       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96387     } catch (std::out_of_range& e) {
96388       {
96389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96390       };
96391     } catch (std::exception& e) {
96392       {
96393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96394       };
96395     } catch (...) {
96396       {
96397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96398       };
96399     }
96400   }
96401 }
96402
96403
96404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96405   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96406   Dali::Window arg2 ;
96407   Dali::Window *argp2 ;
96408
96409   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96410   argp2 = (Dali::Window *)jarg2;
96411   if (!argp2) {
96412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96413     return ;
96414   }
96415   arg2 = *argp2;
96416   {
96417     try {
96418       (arg1)->OnResize(arg2);
96419     } catch (std::out_of_range& e) {
96420       {
96421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96422       };
96423     } catch (std::exception& e) {
96424       {
96425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96426       };
96427     } catch (...) {
96428       {
96429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96430       };
96431     }
96432   }
96433 }
96434
96435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96436   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96437   Dali::Window arg2 ;
96438   Dali::Window *argp2 ;
96439
96440   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96441   argp2 = (Dali::Window *)jarg2;
96442   if (!argp2) {
96443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96444     return ;
96445   }
96446   arg2 = *argp2;
96447   {
96448     try {
96449       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96450     } catch (std::out_of_range& e) {
96451       {
96452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96453       };
96454     } catch (std::exception& e) {
96455       {
96456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96457       };
96458     } catch (...) {
96459       {
96460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96461       };
96462     }
96463   }
96464 }
96465
96466
96467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96468   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96469   std::string *arg2 = 0 ;
96470   int arg3 ;
96471
96472   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96473   if (!jarg2) {
96474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96475     return ;
96476   }
96477   std::string arg2_str(jarg2);
96478   arg2 = &arg2_str;
96479   arg3 = (int)jarg3;
96480   {
96481     try {
96482       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96483     } catch (std::out_of_range& e) {
96484       {
96485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96486       };
96487     } catch (std::exception& e) {
96488       {
96489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96490       };
96491     } catch (...) {
96492       {
96493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96494       };
96495     }
96496   }
96497 }
96498
96499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96500   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96501   std::string *arg2 = 0 ;
96502   int arg3 ;
96503
96504   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96505   if (!jarg2) {
96506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96507     return ;
96508   }
96509   std::string arg2_str(jarg2);
96510   arg2 = &arg2_str;
96511   arg3 = (int)jarg3;
96512   {
96513     try {
96514       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96515     } catch (std::out_of_range& e) {
96516       {
96517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96518       };
96519     } catch (std::exception& e) {
96520       {
96521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96522       };
96523     } catch (...) {
96524       {
96525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96526       };
96527     }
96528   }
96529 }
96530
96531
96532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96533   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96534   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96535   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96536
96537   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96538   arg2 = (Dali::SlotObserver *)jarg2;
96539   arg3 = (Dali::CallbackBase *)jarg3;
96540   {
96541     try {
96542       (arg1)->SignalConnected(arg2,arg3);
96543     } catch (std::out_of_range& e) {
96544       {
96545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96546       };
96547     } catch (std::exception& e) {
96548       {
96549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96550       };
96551     } catch (...) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96554       };
96555     }
96556   }
96557 }
96558
96559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96560   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96561   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96562   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96563
96564   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96565   arg2 = (Dali::SlotObserver *)jarg2;
96566   arg3 = (Dali::CallbackBase *)jarg3;
96567   {
96568     try {
96569       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96570     } catch (std::out_of_range& e) {
96571       {
96572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96573       };
96574     } catch (std::exception& e) {
96575       {
96576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96577       };
96578     } catch (...) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96581       };
96582     }
96583   }
96584 }
96585
96586
96587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96588   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96589   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96590   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96591
96592   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96593   arg2 = (Dali::SlotObserver *)jarg2;
96594   arg3 = (Dali::CallbackBase *)jarg3;
96595   {
96596     try {
96597       (arg1)->SignalDisconnected(arg2,arg3);
96598     } catch (std::out_of_range& e) {
96599       {
96600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96601       };
96602     } catch (std::exception& e) {
96603       {
96604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96605       };
96606     } catch (...) {
96607       {
96608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96609       };
96610     }
96611   }
96612 }
96613
96614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96615   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96616   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96617   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96618
96619   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96620   arg2 = (Dali::SlotObserver *)jarg2;
96621   arg3 = (Dali::CallbackBase *)jarg3;
96622   {
96623     try {
96624       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96625     } catch (std::out_of_range& e) {
96626       {
96627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96628       };
96629     } catch (std::exception& e) {
96630       {
96631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96632       };
96633     } catch (...) {
96634       {
96635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96636       };
96637     }
96638   }
96639 }
96640
96641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96642   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96643   std::string *arg2 = 0 ;
96644
96645   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96646   if (!jarg2) {
96647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96648     return ;
96649   }
96650   std::string arg2_str(jarg2);
96651   arg2 = &arg2_str;
96652   {
96653     try {
96654       (arg1)->SetContentInfo((std::string const &)*arg2);
96655     } catch (std::out_of_range& e) {
96656       {
96657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96658       };
96659     } catch (std::exception& e) {
96660       {
96661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96662       };
96663     } catch (...) {
96664       {
96665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96666       };
96667     }
96668   }
96669 }
96670
96671
96672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96673   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96674   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96675
96676   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96677   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96678   {
96679     try {
96680       (arg1)->SetImpl(arg2);
96681     } catch (std::out_of_range& e) {
96682       {
96683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96684       };
96685     } catch (std::exception& e) {
96686       {
96687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96688       };
96689     } catch (...) {
96690       {
96691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96692       };
96693     }
96694   }
96695 }
96696
96697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_director_connect(void *objarg, SwigDirector_WidgetImpl::SWIG_Callback0_t callback0, SwigDirector_WidgetImpl::SWIG_Callback1_t callback1, SwigDirector_WidgetImpl::SWIG_Callback2_t callback2, SwigDirector_WidgetImpl::SWIG_Callback3_t callback3, SwigDirector_WidgetImpl::SWIG_Callback4_t callback4, SwigDirector_WidgetImpl::SWIG_Callback5_t callback5, SwigDirector_WidgetImpl::SWIG_Callback6_t callback6, SwigDirector_WidgetImpl::SWIG_Callback7_t callback7) {
96698
96699   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96700   if (director) {
96701     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96702   }
96703 }
96704
96705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96706   void * jresult ;
96707   Dali::Widget *arg1 = 0 ;
96708   SwigDirector_WidgetImpl *result = 0 ;
96709
96710   arg1 = (Dali::Widget *)jarg1;
96711   if (!arg1) {
96712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96713     return 0;
96714   }
96715   {
96716     try {
96717       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96725       };
96726     } catch (...) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96729       };
96730     }
96731   }
96732
96733   jresult = (void *)result;
96734   return jresult;
96735 }
96736
96737
96738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96739   void * jresult ;
96740   int *arg1 = (int *) 0 ;
96741   char ***arg2 ;
96742   std::string *arg3 = 0 ;
96743   Dali::WidgetApplication result;
96744   {
96745     int index = 0;
96746     int length = 0;
96747     char *retPtr;
96748     char *nextPtr;
96749     argWidgetC = jarg1;
96750     argWidgetV = new char*[jarg1 + 1];
96751
96752     retPtr = strtok_r( jarg2, " ", &nextPtr);
96753     if( retPtr )
96754     {
96755       length = strlen(retPtr);
96756     }
96757     argWidgetV[index] = new char[length + 1];
96758     if( retPtr )
96759     {
96760       strncpy(argWidgetV[index], retPtr, length);
96761     }
96762     argWidgetV[index][length] = '\0';
96763     index++;
96764
96765     while (index < jarg1)
96766     {
96767       length = 0;
96768       retPtr = strtok_r(NULL, " ", &nextPtr);
96769       if( retPtr )
96770       {
96771         length = strlen(retPtr);
96772       }
96773       argWidgetV[index] = new char[length + 1];
96774       if( retPtr )
96775       {
96776         strncpy(argWidgetV[index], retPtr, length);
96777       }
96778       argWidgetV[index][length] = '\0';
96779       index++;
96780     }
96781
96782     argWidgetV[jarg1] = NULL;
96783     argWidgetC = jarg1;
96784
96785     arg1 = &argWidgetC;
96786     arg2 = &argWidgetV;
96787   }
96788
96789   if (!jarg3) {
96790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96791     return 0;
96792   }
96793   std::string arg3_str(jarg3);
96794   arg3 = &arg3_str;
96795   {
96796     try {
96797       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96798     } catch (std::out_of_range& e) {
96799       {
96800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96801       };
96802     } catch (std::exception& e) {
96803       {
96804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96805       };
96806     } catch (...) {
96807       {
96808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96809       };
96810     }
96811   }
96812   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96813
96814   return jresult;
96815 }
96816
96817
96818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96819   void * jresult ;
96820   Dali::WidgetApplication *result = 0 ;
96821
96822   {
96823     try {
96824       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96825     } catch (std::out_of_range& e) {
96826       {
96827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96828       };
96829     } catch (std::exception& e) {
96830       {
96831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96832       };
96833     } catch (...) {
96834       {
96835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96836       };
96837     }
96838   }
96839   jresult = (void *)result;
96840   return jresult;
96841 }
96842
96843
96844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96845   void * jresult ;
96846   Dali::WidgetApplication *arg1 = 0 ;
96847   Dali::WidgetApplication *result = 0 ;
96848
96849   arg1 = (Dali::WidgetApplication *)jarg1;
96850   if (!arg1) {
96851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96852     return 0;
96853   }
96854   {
96855     try {
96856       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96857     } catch (std::out_of_range& e) {
96858       {
96859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96860       };
96861     } catch (std::exception& e) {
96862       {
96863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96864       };
96865     } catch (...) {
96866       {
96867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96868       };
96869     }
96870   }
96871   jresult = (void *)result;
96872   return jresult;
96873 }
96874
96875
96876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96877   void * jresult ;
96878   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96879   Dali::WidgetApplication *arg2 = 0 ;
96880   Dali::WidgetApplication *result = 0 ;
96881
96882   arg1 = (Dali::WidgetApplication *)jarg1;
96883   arg2 = (Dali::WidgetApplication *)jarg2;
96884   if (!arg2) {
96885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96886     return 0;
96887   }
96888   {
96889     try {
96890       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96891     } catch (std::out_of_range& e) {
96892       {
96893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96894       };
96895     } catch (std::exception& e) {
96896       {
96897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96898       };
96899     } catch (...) {
96900       {
96901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96902       };
96903     }
96904   }
96905   jresult = (void *)result;
96906   return jresult;
96907 }
96908
96909
96910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96911   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96912
96913   arg1 = (Dali::WidgetApplication *)jarg1;
96914   {
96915     try {
96916       delete arg1;
96917       if( argWidgetV )
96918       {
96919         // free string data
96920         for( int i=0; i < argWidgetC+1; i++)
96921         {
96922           delete [] argWidgetV[i];
96923         }
96924         delete [] argWidgetV;
96925       }
96926     } catch (std::out_of_range& e) {
96927       {
96928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96929       };
96930     } catch (std::exception& e) {
96931       {
96932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (...) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96937       };
96938     }
96939   }
96940 }
96941
96942
96943 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96944 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96945
96946 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96947 {
96948   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96949   return *widget;
96950 }
96951
96952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96953   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96954   std::string *arg2 = 0 ;
96955
96956   arg1 = (Dali::WidgetApplication *)jarg1;
96957   if (!jarg2) {
96958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96959     return ;
96960   }
96961   std::string arg2_str(*jarg2);
96962   arg2 = &arg2_str;
96963
96964   if(!_CSharpCreateWidgetFunction)
96965   {
96966     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96967   }
96968
96969   {
96970     try {
96971       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96972     } catch (std::out_of_range& e) {
96973       {
96974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96975       };
96976     } catch (std::exception& e) {
96977       {
96978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96979       };
96980     } catch (...) {
96981       {
96982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96983       };
96984     }
96985   }
96986
96987   //Typemap argout in c++ file.
96988   //This will convert c++ string to c# string
96989   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96990 }
96991
96992
96993 //for PixelBuffer and ImageLoading
96994
96995 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96996     return (Dali::BaseHandle *)jarg1;
96997 }
96998
96999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
97000   void * jresult ;
97001   unsigned int arg1 ;
97002   unsigned int arg2 ;
97003   Dali::Pixel::Format arg3 ;
97004   Dali::Devel::PixelBuffer result;
97005
97006   arg1 = (unsigned int)jarg1;
97007   arg2 = (unsigned int)jarg2;
97008   arg3 = (Dali::Pixel::Format)jarg3;
97009   {
97010     try {
97011       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
97012     } catch (std::out_of_range& e) {
97013       {
97014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97015       };
97016     } catch (std::exception& e) {
97017       {
97018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97019       };
97020     } catch (...) {
97021       {
97022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97023       };
97024     }
97025   }
97026   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97027   return jresult;
97028 }
97029
97030
97031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
97032   void * jresult ;
97033   Dali::Devel::PixelBuffer *result = 0 ;
97034
97035   {
97036     try {
97037       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
97038     } catch (std::out_of_range& e) {
97039       {
97040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97041       };
97042     } catch (std::exception& e) {
97043       {
97044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97045       };
97046     } catch (...) {
97047       {
97048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97049       };
97050     }
97051   }
97052   jresult = (void *)result;
97053   return jresult;
97054 }
97055
97056
97057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
97058   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97059
97060   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97061   {
97062     try {
97063       delete arg1;
97064     } catch (std::out_of_range& e) {
97065       {
97066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97067       };
97068     } catch (std::exception& e) {
97069       {
97070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97071       };
97072     } catch (...) {
97073       {
97074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97075       };
97076     }
97077   }
97078 }
97079
97080
97081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
97082   void * jresult ;
97083   Dali::Devel::PixelBuffer *arg1 = 0 ;
97084   Dali::Devel::PixelBuffer *result = 0 ;
97085
97086   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97087   if (!arg1) {
97088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97089     return 0;
97090   }
97091   {
97092     try {
97093       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
97094     } catch (std::out_of_range& e) {
97095       {
97096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97097       };
97098     } catch (std::exception& e) {
97099       {
97100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97101       };
97102     } catch (...) {
97103       {
97104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97105       };
97106     }
97107   }
97108   jresult = (void *)result;
97109   return jresult;
97110 }
97111
97112
97113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
97114   void * jresult ;
97115   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97116   Dali::Devel::PixelBuffer *arg2 = 0 ;
97117   Dali::Devel::PixelBuffer *result = 0 ;
97118
97119   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97120   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
97121   if (!arg2) {
97122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97123     return 0;
97124   }
97125   {
97126     try {
97127       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
97128     } catch (std::out_of_range& e) {
97129       {
97130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97131       };
97132     } catch (std::exception& e) {
97133       {
97134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97135       };
97136     } catch (...) {
97137       {
97138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97139       };
97140     }
97141   }
97142   jresult = (void *)result;
97143   return jresult;
97144 }
97145
97146
97147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
97148   void * jresult ;
97149   Dali::Devel::PixelBuffer *arg1 = 0 ;
97150   Dali::PixelData result;
97151
97152   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97153   if (!arg1) {
97154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
97155     return 0;
97156   }
97157   {
97158     try {
97159       result = Dali::Devel::PixelBuffer::Convert(*arg1);
97160     } catch (std::out_of_range& e) {
97161       {
97162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97163       };
97164     } catch (std::exception& e) {
97165       {
97166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97167       };
97168     } catch (...) {
97169       {
97170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97171       };
97172     }
97173   }
97174   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97175   return jresult;
97176 }
97177
97178
97179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
97180   void * jresult ;
97181   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97182   Dali::PixelData result;
97183
97184   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97185   {
97186     try {
97187       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (...) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97199       };
97200     }
97201   }
97202   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97203   return jresult;
97204 }
97205
97206
97207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97208   void * jresult ;
97209   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97210   unsigned char *result = 0 ;
97211
97212   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97213   {
97214     try {
97215       result = (unsigned char *)(arg1)->GetBuffer();
97216     } catch (std::out_of_range& e) {
97217       {
97218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97219       };
97220     } catch (std::exception& e) {
97221       {
97222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97223       };
97224     } catch (...) {
97225       {
97226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97227       };
97228     }
97229   }
97230   jresult = (void *)result;
97231   return jresult;
97232 }
97233
97234
97235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97236   unsigned int jresult ;
97237   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97238   unsigned int result;
97239
97240   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97241   {
97242     try {
97243       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97244     } catch (std::out_of_range& e) {
97245       {
97246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97247       };
97248     } catch (std::exception& e) {
97249       {
97250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97251       };
97252     } catch (...) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97255       };
97256     }
97257   }
97258   jresult = result;
97259   return jresult;
97260 }
97261
97262
97263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97264   unsigned int jresult ;
97265   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97266   unsigned int result;
97267
97268   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97269   {
97270     try {
97271       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97272     } catch (std::out_of_range& e) {
97273       {
97274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97275       };
97276     } catch (std::exception& e) {
97277       {
97278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97279       };
97280     } catch (...) {
97281       {
97282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97283       };
97284     }
97285   }
97286   jresult = result;
97287   return jresult;
97288 }
97289
97290
97291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97292   int jresult ;
97293   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97294   Dali::Pixel::Format result;
97295
97296   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97297   {
97298     try {
97299       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97300     } catch (std::out_of_range& e) {
97301       {
97302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97303       };
97304     } catch (std::exception& e) {
97305       {
97306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97307       };
97308     } catch (...) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97311       };
97312     }
97313   }
97314   jresult = (int)result;
97315   return jresult;
97316 }
97317
97318
97319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97320   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97321   Dali::Devel::PixelBuffer arg2 ;
97322   float arg3 ;
97323   bool arg4 ;
97324   Dali::Devel::PixelBuffer *argp2 ;
97325
97326   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97327   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97328   if (!argp2) {
97329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97330     return ;
97331   }
97332   arg2 = *argp2;
97333   arg3 = (float)jarg3;
97334   arg4 = jarg4 ? true : false;
97335   {
97336     try {
97337       (arg1)->ApplyMask(arg2,arg3,arg4);
97338     } catch (std::out_of_range& e) {
97339       {
97340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97341       };
97342     } catch (std::exception& e) {
97343       {
97344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97345       };
97346     } catch (...) {
97347       {
97348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97349       };
97350     }
97351   }
97352 }
97353
97354
97355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97356   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97357   Dali::Devel::PixelBuffer arg2 ;
97358   float arg3 ;
97359   Dali::Devel::PixelBuffer *argp2 ;
97360
97361   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97362   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97363   if (!argp2) {
97364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97365     return ;
97366   }
97367   arg2 = *argp2;
97368   arg3 = (float)jarg3;
97369   {
97370     try {
97371       (arg1)->ApplyMask(arg2,arg3);
97372     } catch (std::out_of_range& e) {
97373       {
97374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97375       };
97376     } catch (std::exception& e) {
97377       {
97378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97379       };
97380     } catch (...) {
97381       {
97382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97383       };
97384     }
97385   }
97386 }
97387
97388
97389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97390   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97391   Dali::Devel::PixelBuffer arg2 ;
97392   Dali::Devel::PixelBuffer *argp2 ;
97393
97394   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97395   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97396   if (!argp2) {
97397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97398     return ;
97399   }
97400   arg2 = *argp2;
97401   {
97402     try {
97403       (arg1)->ApplyMask(arg2);
97404     } catch (std::out_of_range& e) {
97405       {
97406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97407       };
97408     } catch (std::exception& e) {
97409       {
97410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97411       };
97412     } catch (...) {
97413       {
97414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97415       };
97416     }
97417   }
97418 }
97419
97420
97421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97422   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97423   float arg2 ;
97424
97425   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97426   arg2 = (float)jarg2;
97427   {
97428     try {
97429       (arg1)->ApplyGaussianBlur(arg2);
97430     } catch (std::out_of_range& e) {
97431       {
97432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97433       };
97434     } catch (std::exception& e) {
97435       {
97436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97437       };
97438     } catch (...) {
97439       {
97440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97441       };
97442     }
97443   }
97444 }
97445
97446
97447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97448   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97449   uint16_t arg2 ;
97450   uint16_t arg3 ;
97451   uint16_t arg4 ;
97452   uint16_t arg5 ;
97453
97454   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97455   arg2 = (uint16_t)jarg2;
97456   arg3 = (uint16_t)jarg3;
97457   arg4 = (uint16_t)jarg4;
97458   arg5 = (uint16_t)jarg5;
97459   {
97460     try {
97461       (arg1)->Crop(arg2,arg3,arg4,arg5);
97462     } catch (std::out_of_range& e) {
97463       {
97464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97465       };
97466     } catch (std::exception& e) {
97467       {
97468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97469       };
97470     } catch (...) {
97471       {
97472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97473       };
97474     }
97475   }
97476 }
97477
97478
97479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97480   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97481   uint16_t arg2 ;
97482   uint16_t arg3 ;
97483
97484   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97485   arg2 = (uint16_t)jarg2;
97486   arg3 = (uint16_t)jarg3;
97487   {
97488     try {
97489       (arg1)->Resize(arg2,arg3);
97490     } catch (std::out_of_range& e) {
97491       {
97492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97493       };
97494     } catch (std::exception& e) {
97495       {
97496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97497       };
97498     } catch (...) {
97499       {
97500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97501       };
97502     }
97503   }
97504 }
97505
97506 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97507   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97508   Dali::Degree * arg2 ;
97509
97510   bool result = false;
97511
97512   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97513   arg2 = (Dali::Degree *)jarg2;
97514   {
97515     try {
97516       result = (arg1)->Rotate(*arg2);
97517     } catch (std::out_of_range& e) {
97518       {
97519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97520       };
97521     } catch (std::exception& e) {
97522       {
97523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97524       };
97525     } catch (...) {
97526       {
97527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97528       };
97529     }
97530   }
97531   return result;
97532 }
97533
97534
97535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97536   void * jresult ;
97537   std::string *arg1 = 0 ;
97538   Dali::ImageDimensions arg2 ;
97539   Dali::FittingMode::Type arg3 ;
97540   Dali::SamplingMode::Type arg4 ;
97541   bool arg5 ;
97542   Dali::ImageDimensions *argp2 ;
97543   Dali::Devel::PixelBuffer result;
97544
97545   if (!jarg1) {
97546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97547     return 0;
97548   }
97549   std::string arg1_str(jarg1);
97550   arg1 = &arg1_str;
97551   argp2 = (Dali::ImageDimensions *)jarg2;
97552   if (!argp2) {
97553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97554     return 0;
97555   }
97556   arg2 = *argp2;
97557   arg3 = (Dali::FittingMode::Type)jarg3;
97558   arg4 = (Dali::SamplingMode::Type)jarg4;
97559   arg5 = jarg5 ? true : false;
97560   {
97561     try {
97562       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97563     } catch (std::out_of_range& e) {
97564       {
97565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97566       };
97567     } catch (std::exception& e) {
97568       {
97569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97570       };
97571     } catch (...) {
97572       {
97573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97574       };
97575     }
97576   }
97577   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97578
97579   return jresult;
97580 }
97581
97582
97583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97584   void * jresult ;
97585   std::string *arg1 = 0 ;
97586   Dali::ImageDimensions arg2 ;
97587   Dali::FittingMode::Type arg3 ;
97588   Dali::SamplingMode::Type arg4 ;
97589   Dali::ImageDimensions *argp2 ;
97590   Dali::Devel::PixelBuffer result;
97591
97592   if (!jarg1) {
97593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97594     return 0;
97595   }
97596   std::string arg1_str(jarg1);
97597   arg1 = &arg1_str;
97598   argp2 = (Dali::ImageDimensions *)jarg2;
97599   if (!argp2) {
97600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97601     return 0;
97602   }
97603   arg2 = *argp2;
97604   arg3 = (Dali::FittingMode::Type)jarg3;
97605   arg4 = (Dali::SamplingMode::Type)jarg4;
97606   {
97607     try {
97608       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97609     } catch (std::out_of_range& e) {
97610       {
97611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97612       };
97613     } catch (std::exception& e) {
97614       {
97615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97616       };
97617     } catch (...) {
97618       {
97619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97620       };
97621     }
97622   }
97623   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97624
97625   return jresult;
97626 }
97627
97628
97629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97630   void * jresult ;
97631   std::string *arg1 = 0 ;
97632   Dali::ImageDimensions arg2 ;
97633   Dali::FittingMode::Type arg3 ;
97634   Dali::ImageDimensions *argp2 ;
97635   Dali::Devel::PixelBuffer result;
97636
97637   if (!jarg1) {
97638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97639     return 0;
97640   }
97641   std::string arg1_str(jarg1);
97642   arg1 = &arg1_str;
97643   argp2 = (Dali::ImageDimensions *)jarg2;
97644   if (!argp2) {
97645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97646     return 0;
97647   }
97648   arg2 = *argp2;
97649   arg3 = (Dali::FittingMode::Type)jarg3;
97650   {
97651     try {
97652       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97653     } catch (std::out_of_range& e) {
97654       {
97655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97656       };
97657     } catch (std::exception& e) {
97658       {
97659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97660       };
97661     } catch (...) {
97662       {
97663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97664       };
97665     }
97666   }
97667   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97668
97669   return jresult;
97670 }
97671
97672
97673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97674   void * jresult ;
97675   std::string *arg1 = 0 ;
97676   Dali::ImageDimensions arg2 ;
97677   Dali::ImageDimensions *argp2 ;
97678   Dali::Devel::PixelBuffer result;
97679
97680   if (!jarg1) {
97681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97682     return 0;
97683   }
97684   std::string arg1_str(jarg1);
97685   arg1 = &arg1_str;
97686   argp2 = (Dali::ImageDimensions *)jarg2;
97687   if (!argp2) {
97688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97689     return 0;
97690   }
97691   arg2 = *argp2;
97692   {
97693     try {
97694       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97695     } catch (std::out_of_range& e) {
97696       {
97697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97698       };
97699     } catch (std::exception& e) {
97700       {
97701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97702       };
97703     } catch (...) {
97704       {
97705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97706       };
97707     }
97708   }
97709   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97710
97711   return jresult;
97712 }
97713
97714
97715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97716   void * jresult ;
97717   std::string *arg1 = 0 ;
97718   Dali::Devel::PixelBuffer result;
97719
97720   if (!jarg1) {
97721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97722     return 0;
97723   }
97724   std::string arg1_str(jarg1);
97725   arg1 = &arg1_str;
97726   {
97727     try {
97728       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97729     } catch (std::out_of_range& e) {
97730       {
97731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97732       };
97733     } catch (std::exception& e) {
97734       {
97735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97736       };
97737     } catch (...) {
97738       {
97739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97740       };
97741     }
97742   }
97743   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97744
97745   return jresult;
97746 }
97747
97748
97749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97750   void * jresult ;
97751   std::string *arg1 = 0 ;
97752   Dali::ImageDimensions arg2 ;
97753   Dali::FittingMode::Type arg3 ;
97754   Dali::SamplingMode::Type arg4 ;
97755   bool arg5 ;
97756   Dali::ImageDimensions *argp2 ;
97757   Dali::ImageDimensions result;
97758
97759   if (!jarg1) {
97760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97761     return 0;
97762   }
97763   std::string arg1_str(jarg1);
97764   arg1 = &arg1_str;
97765   argp2 = (Dali::ImageDimensions *)jarg2;
97766   if (!argp2) {
97767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97768     return 0;
97769   }
97770   arg2 = *argp2;
97771   arg3 = (Dali::FittingMode::Type)jarg3;
97772   arg4 = (Dali::SamplingMode::Type)jarg4;
97773   arg5 = jarg5 ? true : false;
97774   {
97775     try {
97776       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97777     } catch (std::out_of_range& e) {
97778       {
97779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97780       };
97781     } catch (std::exception& e) {
97782       {
97783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97784       };
97785     } catch (...) {
97786       {
97787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97788       };
97789     }
97790   }
97791   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97792
97793   return jresult;
97794 }
97795
97796
97797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97798   void * jresult ;
97799   std::string *arg1 = 0 ;
97800   Dali::ImageDimensions arg2 ;
97801   Dali::FittingMode::Type arg3 ;
97802   Dali::SamplingMode::Type arg4 ;
97803   Dali::ImageDimensions *argp2 ;
97804   Dali::ImageDimensions result;
97805
97806   if (!jarg1) {
97807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97808     return 0;
97809   }
97810   std::string arg1_str(jarg1);
97811   arg1 = &arg1_str;
97812   argp2 = (Dali::ImageDimensions *)jarg2;
97813   if (!argp2) {
97814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97815     return 0;
97816   }
97817   arg2 = *argp2;
97818   arg3 = (Dali::FittingMode::Type)jarg3;
97819   arg4 = (Dali::SamplingMode::Type)jarg4;
97820   {
97821     try {
97822       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97823     } catch (std::out_of_range& e) {
97824       {
97825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97826       };
97827     } catch (std::exception& e) {
97828       {
97829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97830       };
97831     } catch (...) {
97832       {
97833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97834       };
97835     }
97836   }
97837   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97838
97839   return jresult;
97840 }
97841
97842
97843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97844   void * jresult ;
97845   std::string *arg1 = 0 ;
97846   Dali::ImageDimensions arg2 ;
97847   Dali::FittingMode::Type arg3 ;
97848   Dali::ImageDimensions *argp2 ;
97849   Dali::ImageDimensions result;
97850
97851   if (!jarg1) {
97852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97853     return 0;
97854   }
97855   std::string arg1_str(jarg1);
97856   arg1 = &arg1_str;
97857   argp2 = (Dali::ImageDimensions *)jarg2;
97858   if (!argp2) {
97859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97860     return 0;
97861   }
97862   arg2 = *argp2;
97863   arg3 = (Dali::FittingMode::Type)jarg3;
97864   {
97865     try {
97866       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97867     } catch (std::out_of_range& e) {
97868       {
97869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97870       };
97871     } catch (std::exception& e) {
97872       {
97873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97874       };
97875     } catch (...) {
97876       {
97877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97878       };
97879     }
97880   }
97881   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97882
97883   return jresult;
97884 }
97885
97886
97887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97888   void * jresult ;
97889   std::string *arg1 = 0 ;
97890   Dali::ImageDimensions arg2 ;
97891   Dali::ImageDimensions *argp2 ;
97892   Dali::ImageDimensions result;
97893
97894   if (!jarg1) {
97895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97896     return 0;
97897   }
97898   std::string arg1_str(jarg1);
97899   arg1 = &arg1_str;
97900   argp2 = (Dali::ImageDimensions *)jarg2;
97901   if (!argp2) {
97902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97903     return 0;
97904   }
97905   arg2 = *argp2;
97906   {
97907     try {
97908       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97909     } catch (std::out_of_range& e) {
97910       {
97911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97912       };
97913     } catch (std::exception& e) {
97914       {
97915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97916       };
97917     } catch (...) {
97918       {
97919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97920       };
97921     }
97922   }
97923   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97924
97925   return jresult;
97926 }
97927
97928
97929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97930   void * jresult ;
97931   std::string *arg1 = 0 ;
97932   Dali::ImageDimensions result;
97933
97934   if (!jarg1) {
97935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97936     return 0;
97937   }
97938   std::string arg1_str(jarg1);
97939   arg1 = &arg1_str;
97940   {
97941     try {
97942       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97943     } catch (std::out_of_range& e) {
97944       {
97945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97946       };
97947     } catch (std::exception& e) {
97948       {
97949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97950       };
97951     } catch (...) {
97952       {
97953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97954       };
97955     }
97956   }
97957   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97958
97959   return jresult;
97960 }
97961
97962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97963   void * jresult ;
97964   std::string *arg1 = 0 ;
97965   Dali::ImageDimensions result;
97966
97967   if (!jarg1) {
97968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97969     return 0;
97970   }
97971   std::string arg1_str(jarg1);
97972   arg1 = &arg1_str;
97973   {
97974     try {
97975       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97976     } catch (std::out_of_range& e) {
97977       {
97978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97979       };
97980     } catch (std::exception& e) {
97981       {
97982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97983       };
97984     } catch (...) {
97985       {
97986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97987       };
97988     }
97989   }
97990   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97991
97992   return jresult;
97993 }
97994
97995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97996   void * jresult ;
97997   std::string *arg1 = 0 ;
97998   Dali::ImageDimensions arg2 ;
97999   Dali::FittingMode::Type arg3 ;
98000   Dali::SamplingMode::Type arg4 ;
98001   bool arg5 ;
98002   Dali::ImageDimensions *argp2 ;
98003   Dali::Devel::PixelBuffer result;
98004
98005   if (!jarg1) {
98006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98007     return 0;
98008   }
98009   std::string arg1_str(jarg1);
98010   arg1 = &arg1_str;
98011   argp2 = (Dali::ImageDimensions *)jarg2;
98012   if (!argp2) {
98013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98014     return 0;
98015   }
98016   arg2 = *argp2;
98017   arg3 = (Dali::FittingMode::Type)jarg3;
98018   arg4 = (Dali::SamplingMode::Type)jarg4;
98019   arg5 = jarg5 ? true : false;
98020   {
98021     try {
98022       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98023     } catch (std::out_of_range& e) {
98024       {
98025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98026       };
98027     } catch (std::exception& e) {
98028       {
98029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98030       };
98031     } catch (...) {
98032       {
98033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98034       };
98035     }
98036   }
98037   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98038
98039   return jresult;
98040 }
98041
98042
98043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98044   void * jresult ;
98045   std::string *arg1 = 0 ;
98046   Dali::ImageDimensions arg2 ;
98047   Dali::FittingMode::Type arg3 ;
98048   Dali::SamplingMode::Type arg4 ;
98049   Dali::ImageDimensions *argp2 ;
98050   Dali::Devel::PixelBuffer result;
98051
98052   if (!jarg1) {
98053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98054     return 0;
98055   }
98056   std::string arg1_str(jarg1);
98057   arg1 = &arg1_str;
98058   argp2 = (Dali::ImageDimensions *)jarg2;
98059   if (!argp2) {
98060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98061     return 0;
98062   }
98063   arg2 = *argp2;
98064   arg3 = (Dali::FittingMode::Type)jarg3;
98065   arg4 = (Dali::SamplingMode::Type)jarg4;
98066   {
98067     try {
98068       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
98069     } catch (std::out_of_range& e) {
98070       {
98071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98072       };
98073     } catch (std::exception& e) {
98074       {
98075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98076       };
98077     } catch (...) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98080       };
98081     }
98082   }
98083   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98084
98085   return jresult;
98086 }
98087
98088
98089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98090   void * jresult ;
98091   std::string *arg1 = 0 ;
98092   Dali::ImageDimensions arg2 ;
98093   Dali::FittingMode::Type arg3 ;
98094   Dali::ImageDimensions *argp2 ;
98095   Dali::Devel::PixelBuffer result;
98096
98097   if (!jarg1) {
98098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98099     return 0;
98100   }
98101   std::string arg1_str(jarg1);
98102   arg1 = &arg1_str;
98103   argp2 = (Dali::ImageDimensions *)jarg2;
98104   if (!argp2) {
98105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98106     return 0;
98107   }
98108   arg2 = *argp2;
98109   arg3 = (Dali::FittingMode::Type)jarg3;
98110   {
98111     try {
98112       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
98113     } catch (std::out_of_range& e) {
98114       {
98115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98116       };
98117     } catch (std::exception& e) {
98118       {
98119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98120       };
98121     } catch (...) {
98122       {
98123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98124       };
98125     }
98126   }
98127   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98128
98129   return jresult;
98130 }
98131
98132
98133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
98134   void * jresult ;
98135   std::string *arg1 = 0 ;
98136   Dali::ImageDimensions arg2 ;
98137   Dali::ImageDimensions *argp2 ;
98138   Dali::Devel::PixelBuffer result;
98139
98140   if (!jarg1) {
98141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98142     return 0;
98143   }
98144   std::string arg1_str(jarg1);
98145   arg1 = &arg1_str;
98146   argp2 = (Dali::ImageDimensions *)jarg2;
98147   if (!argp2) {
98148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98149     return 0;
98150   }
98151   arg2 = *argp2;
98152   {
98153     try {
98154       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
98155     } catch (std::out_of_range& e) {
98156       {
98157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98158       };
98159     } catch (std::exception& e) {
98160       {
98161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98162       };
98163     } catch (...) {
98164       {
98165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98166       };
98167     }
98168   }
98169   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98170
98171   return jresult;
98172 }
98173
98174
98175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
98176   void * jresult ;
98177   std::string *arg1 = 0 ;
98178   Dali::Devel::PixelBuffer result;
98179
98180   if (!jarg1) {
98181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98182     return 0;
98183   }
98184   std::string arg1_str(jarg1);
98185   arg1 = &arg1_str;
98186   {
98187     try {
98188       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98189     } catch (std::out_of_range& e) {
98190       {
98191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98192       };
98193     } catch (std::exception& e) {
98194       {
98195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98196       };
98197     } catch (...) {
98198       {
98199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98200       };
98201     }
98202   }
98203   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98204
98205   return jresult;
98206 }
98207
98208
98209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98210   void * jresult ;
98211   Dali::Toolkit::WebView result;
98212
98213   {
98214     try {
98215       result = Dali::Toolkit::WebView::New();
98216     } catch (std::out_of_range& e) {
98217       {
98218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98219       };
98220     } catch (std::exception& e) {
98221       {
98222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98223       };
98224     } catch (Dali::DaliException e) {
98225       {
98226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98227       };
98228     } catch (...) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98231       };
98232     }
98233   }
98234   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98235   return jresult;
98236 }
98237
98238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98239   void * jresult ;
98240   Dali::Toolkit::WebView result;
98241
98242   std::string *arg1;
98243   std::string *arg2;
98244
98245   if (!jarg1) {
98246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98247     return 0;
98248   }
98249   if (!jarg2) {
98250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98251     return 0;
98252   }
98253
98254   std::string jarg1_str = std::string(jarg1);
98255   std::string jarg2_str = std::string(jarg2);
98256
98257   arg1 = &jarg1_str;
98258   arg2 = &jarg2_str;
98259
98260   {
98261     try {
98262       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98263     } catch (std::out_of_range& e) {
98264       {
98265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98266       };
98267     } catch (std::exception& e) {
98268       {
98269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98270       };
98271     } catch (Dali::DaliException e) {
98272       {
98273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98274       };
98275     } catch (...) {
98276       {
98277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98278       };
98279     }
98280   }
98281   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98282   return jresult;
98283 }
98284
98285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98286   void * jresult ;
98287   Dali::Toolkit::WebView *arg1 = 0 ;
98288   Dali::Toolkit::WebView *result = 0 ;
98289
98290   arg1 = (Dali::Toolkit::WebView *)jarg1;
98291   if (!arg1) {
98292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98293     return 0;
98294   }
98295   {
98296     try {
98297       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98298     } catch (std::out_of_range& e) {
98299       {
98300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98301       };
98302     } catch (std::exception& e) {
98303       {
98304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98305       };
98306     } catch (Dali::DaliException e) {
98307       {
98308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98309       };
98310     } catch (...) {
98311       {
98312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98313       };
98314     }
98315   }
98316   jresult = (void *)result;
98317   return jresult;
98318 }
98319
98320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98321   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98322   arg1 = (Dali::Toolkit::WebView *)jarg1;
98323   {
98324     try {
98325       delete arg1;
98326     } catch (std::out_of_range& e) {
98327       {
98328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98329       };
98330     } catch (std::exception& e) {
98331       {
98332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98333       };
98334     } catch (Dali::DaliException e) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98337       };
98338     } catch (...) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98341       };
98342     }
98343   }
98344 }
98345
98346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98347   void * jresult ;
98348   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98349   Dali::Toolkit::WebView *arg2 = 0 ;
98350   Dali::Toolkit::WebView *result = 0 ;
98351
98352   arg1 = (Dali::Toolkit::WebView *)jarg1;
98353   arg2 = (Dali::Toolkit::WebView *)jarg2;
98354   if (!arg2) {
98355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98356     return 0;
98357   }
98358   {
98359     try {
98360       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98368       };
98369     } catch (Dali::DaliException e) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98376       };
98377     }
98378   }
98379   jresult = (void *)result;
98380   return jresult;
98381 }
98382
98383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98384   void * jresult ;
98385   Dali::BaseHandle arg1 ;
98386   Dali::BaseHandle *argp1 ;
98387   Dali::Toolkit::WebView result;
98388
98389   argp1 = (Dali::BaseHandle *)jarg1;
98390   if (!argp1) {
98391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98392     return 0;
98393   }
98394   arg1 = *argp1;
98395   {
98396     try {
98397       result = Dali::Toolkit::WebView::DownCast(arg1);
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (Dali::DaliException e) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98409       };
98410     } catch (...) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98413       };
98414     }
98415   }
98416   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98417   return jresult;
98418 }
98419
98420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98421   return (int) Dali::Toolkit::WebView::Property::URL;
98422 }
98423
98424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98425   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98426 }
98427
98428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98429   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98430 }
98431
98432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98433   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98434 }
98435
98436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98437   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98438 }
98439
98440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98441   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98442 }
98443
98444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98445   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98446 }
98447
98448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98449   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98450 }
98451
98452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98453   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98454   std::string *arg2;
98455
98456   arg1 = (Dali::Toolkit::WebView *)jarg1;
98457
98458   if (!jarg2) {
98459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98460     return;
98461   }
98462
98463   std::string jarg2str = std::string(jarg2);
98464   arg2 = &jarg2str;
98465   {
98466     try {
98467       (arg1)->LoadUrl((std::string const &)*arg2);
98468     } catch (std::out_of_range& e) {
98469       {
98470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (std::exception& e) {
98473       {
98474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98475       };
98476     } catch (Dali::DaliException e) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98479       };
98480     } catch (...) {
98481       {
98482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98483       };
98484     }
98485   }
98486 }
98487
98488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98489   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98490   std::string *arg2;
98491
98492   arg1 = (Dali::Toolkit::WebView *)jarg1;
98493   if (!jarg2) {
98494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98495     return;
98496   }
98497   std::string jarg2str = std::string(jarg2);
98498   arg2 = &jarg2str;
98499   {
98500     try {
98501       (arg1)->LoadHTMLString((std::string const &)*arg2);
98502     } catch (std::out_of_range& e) {
98503       {
98504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98505       };
98506     } catch (std::exception& e) {
98507       {
98508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98509       };
98510     } catch (Dali::DaliException e) {
98511       {
98512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98513       };
98514     } catch (...) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98517       };
98518     }
98519   }
98520 }
98521
98522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98523   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98524
98525   arg1 = (Dali::Toolkit::WebView *)jarg1;
98526   {
98527     try {
98528       (arg1)->Reload();
98529     } catch (std::out_of_range& e) {
98530       {
98531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98532       };
98533     } catch (std::exception& e) {
98534       {
98535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98536       };
98537     } catch (Dali::DaliException e) {
98538       {
98539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98540       };
98541     } catch (...) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98544       };
98545     }
98546   }
98547 }
98548
98549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98550   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98551
98552   arg1 = (Dali::Toolkit::WebView *)jarg1;
98553   {
98554     try {
98555       (arg1)->StopLoading();
98556     } catch (std::out_of_range& e) {
98557       {
98558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98559       };
98560     } catch (std::exception& e) {
98561       {
98562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98563       };
98564     } catch (Dali::DaliException e) {
98565       {
98566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98567       };
98568     } catch (...) {
98569       {
98570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98571       };
98572     }
98573   }
98574 }
98575
98576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98577   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98578
98579   arg1 = (Dali::Toolkit::WebView *)jarg1;
98580   {
98581     try {
98582       (arg1)->Suspend();
98583     } catch (std::out_of_range& e) {
98584       {
98585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98586       };
98587     } catch (std::exception& e) {
98588       {
98589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98590       };
98591     } catch (Dali::DaliException e) {
98592       {
98593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98594       };
98595     } catch (...) {
98596       {
98597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98598       };
98599     }
98600   }
98601 }
98602
98603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98604   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98605
98606   arg1 = (Dali::Toolkit::WebView *)jarg1;
98607   {
98608     try {
98609       (arg1)->Resume();
98610     } catch (std::out_of_range& e) {
98611       {
98612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98613       };
98614     } catch (std::exception& e) {
98615       {
98616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98617       };
98618     } catch (Dali::DaliException e) {
98619       {
98620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98621       };
98622     } catch (...) {
98623       {
98624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98625       };
98626     }
98627   }
98628 }
98629
98630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98631   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98632
98633   arg1 = (Dali::Toolkit::WebView *)jarg1;
98634   {
98635     try {
98636       (arg1)->GoBack();
98637     } catch (std::out_of_range& e) {
98638       {
98639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98640       };
98641     } catch (std::exception& e) {
98642       {
98643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98644       };
98645     } catch (Dali::DaliException e) {
98646       {
98647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98648       };
98649     } catch (...) {
98650       {
98651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98652       };
98653     }
98654   }
98655 }
98656
98657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98658   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98659
98660   arg1 = (Dali::Toolkit::WebView *)jarg1;
98661   {
98662     try {
98663       (arg1)->GoForward();
98664     } catch (std::out_of_range& e) {
98665       {
98666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98667       };
98668     } catch (std::exception& e) {
98669       {
98670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98671       };
98672     } catch (Dali::DaliException e) {
98673       {
98674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98675       };
98676     } catch (...) {
98677       {
98678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98679       };
98680     }
98681   }
98682 }
98683
98684 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98685   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98686   bool ret;
98687
98688   arg1 = (Dali::Toolkit::WebView *)jarg1;
98689   {
98690     try {
98691       ret = (arg1)->CanGoBack();
98692     } catch (std::out_of_range& e) {
98693       {
98694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98695       };
98696     } catch (std::exception& e) {
98697       {
98698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98699       };
98700     } catch (Dali::DaliException e) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98703       };
98704     } catch (...) {
98705       {
98706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98707       };
98708     }
98709   }
98710   return ret;
98711 }
98712
98713 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98714   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98715   bool ret;
98716
98717   arg1 = (Dali::Toolkit::WebView *)jarg1;
98718   {
98719     try {
98720       ret = (arg1)->CanGoForward();
98721     } catch (std::out_of_range& e) {
98722       {
98723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98724       };
98725     } catch (std::exception& e) {
98726       {
98727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98728       };
98729     } catch (Dali::DaliException e) {
98730       {
98731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98732       };
98733     } catch (...) {
98734       {
98735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98736       };
98737     }
98738   }
98739   return ret;
98740 }
98741
98742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98743   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98744   std::string *arg2;
98745
98746   arg1 = (Dali::Toolkit::WebView *)jarg1;
98747   if (!jarg2) {
98748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98749     return;
98750   }
98751   std::string jarg2_str = std::string(jarg2);
98752   arg2 = &jarg2_str;
98753
98754   {
98755     try {
98756       if (jarg3) {
98757         void (*handler)(char*) = (void (*)(char*)) jarg3;
98758         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98759           handler(SWIG_csharp_string_callback(result.c_str()));
98760         });
98761       } else {
98762         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98763       }
98764     } catch (std::out_of_range& e) {
98765       {
98766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98767       };
98768     } catch (std::exception& e) {
98769       {
98770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98771       };
98772     } catch (Dali::DaliException e) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98775       };
98776     } catch (...) {
98777       {
98778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98779       };
98780     }
98781   }
98782 }
98783
98784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98785 {
98786   if (!jarg2) {
98787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98788     return;
98789   }
98790
98791   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98792   std::string exposedObjectName = jarg2;
98793   void (*handler)(char*) = (void (*)(char*)) jarg3;
98794
98795   {
98796     try {
98797       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98798         handler(SWIG_csharp_string_callback(message.c_str()));
98799       });
98800     } catch (std::out_of_range& e) {
98801       {
98802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98803       };
98804     } catch (std::exception& e) {
98805       {
98806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98807       };
98808     } catch (Dali::DaliException e) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98811       };
98812     } catch (...) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98815       };
98816     }
98817   }
98818 }
98819
98820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98821   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98822
98823   arg1 = (Dali::Toolkit::WebView *)jarg1;
98824   {
98825     try {
98826       (arg1)->ClearHistory();
98827     } catch (std::out_of_range& e) {
98828       {
98829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98830       };
98831     } catch (std::exception& e) {
98832       {
98833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98834       };
98835     } catch (Dali::DaliException e) {
98836       {
98837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98838       };
98839     } catch (...) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98842       };
98843     }
98844   }
98845 }
98846
98847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98848   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98849
98850   arg1 = (Dali::Toolkit::WebView *)jarg1;
98851   {
98852     try {
98853       (arg1)->ClearCache();
98854     } catch (std::out_of_range& e) {
98855       {
98856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98857       };
98858     } catch (std::exception& e) {
98859       {
98860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98861       };
98862     } catch (Dali::DaliException e) {
98863       {
98864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98865       };
98866     } catch (...) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98869       };
98870     }
98871   }
98872 }
98873
98874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98875   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98876
98877   arg1 = (Dali::Toolkit::WebView *)jarg1;
98878   {
98879     try {
98880       (arg1)->ClearCookies();
98881     } catch (std::out_of_range& e) {
98882       {
98883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98884       };
98885     } catch (std::exception& e) {
98886       {
98887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98888       };
98889     } catch (Dali::DaliException e) {
98890       {
98891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98892       };
98893     } catch (...) {
98894       {
98895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98896       };
98897     }
98898   }
98899 }
98900
98901 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98902     return (Dali::Toolkit::Control *)jarg1;
98903 }
98904
98905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98906   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98907   SignalConverter::WebViewPageLoadSignal* result = NULL;
98908   {
98909     try {
98910       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98911     } catch (std::out_of_range& e) {
98912       {
98913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98914       };
98915     } catch (std::exception& e) {
98916       {
98917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98918       };
98919     } catch (Dali::DaliException e) {
98920       {
98921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98922       };
98923     } catch (...) {
98924       {
98925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98926       };
98927     }
98928   }
98929   return (void*) result;
98930 }
98931
98932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98933   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98934   SignalConverter::WebViewPageLoadSignal* result = NULL;
98935   {
98936     try {
98937       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98938     } catch (std::out_of_range& e) {
98939       {
98940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98941       };
98942     } catch (std::exception& e) {
98943       {
98944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98945       };
98946     } catch (Dali::DaliException e) {
98947       {
98948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98949       };
98950     } catch (...) {
98951       {
98952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98953       };
98954     }
98955   }
98956   return (void*) result;
98957 }
98958
98959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98960 {
98961   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98962   {
98963     try {
98964       delete object;
98965     } catch (std::out_of_range& e) {
98966       {
98967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98968       };
98969     } catch (std::exception& e) {
98970       {
98971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98972       };
98973     } catch (Dali::DaliException e) {
98974       {
98975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98976       };
98977     } catch (...) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98980       };
98981     }
98982   }
98983 }
98984
98985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98986 {
98987   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98988   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98989   {
98990     try {
98991       proxy->Connect(callback);
98992     } catch (std::out_of_range& e) {
98993       {
98994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98995       };
98996     } catch (std::exception& e) {
98997       {
98998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98999       };
99000     } catch (Dali::DaliException e) {
99001       {
99002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99003       };
99004     } catch (...) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99007       };
99008     }
99009   }
99010 }
99011
99012
99013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
99014   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99015   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99016   {
99017     try {
99018       proxy->Disconnect(callback);
99019     } catch (std::out_of_range& e) {
99020       {
99021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99022       };
99023     } catch (std::exception& e) {
99024       {
99025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99026       };
99027     } catch (Dali::DaliException e) {
99028       {
99029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99030       };
99031     } catch (...) {
99032       {
99033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99034       };
99035     }
99036   }
99037 }
99038
99039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
99040   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99041   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
99042   {
99043     try {
99044       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
99045     } catch (std::out_of_range& e) {
99046       {
99047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99048       };
99049     } catch (std::exception& e) {
99050       {
99051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99052       };
99053     } catch (Dali::DaliException e) {
99054       {
99055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99056       };
99057     } catch (...) {
99058       {
99059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99060       };
99061     }
99062   }
99063   return (void*) result;
99064 }
99065
99066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
99067 {
99068   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99069   {
99070     try {
99071       delete object;
99072     } catch (std::out_of_range& e) {
99073       {
99074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99075       };
99076     } catch (std::exception& e) {
99077       {
99078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99079       };
99080     } catch (Dali::DaliException e) {
99081       {
99082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99083       };
99084     } catch (...) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99087       };
99088     }
99089   }
99090 }
99091
99092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
99093 {
99094   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99095   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99096   {
99097     try {
99098       proxy->Connect(callback);
99099     } catch (std::out_of_range& e) {
99100       {
99101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99102       };
99103     } catch (std::exception& e) {
99104       {
99105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99106       };
99107     } catch (Dali::DaliException e) {
99108       {
99109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99110       };
99111     } catch (...) {
99112       {
99113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99114       };
99115     }
99116   }
99117 }
99118
99119
99120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
99121   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99122   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99123   {
99124     try {
99125       proxy->Disconnect(callback);
99126     } catch (std::out_of_range& e) {
99127       {
99128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99129       };
99130     } catch (std::exception& e) {
99131       {
99132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99133       };
99134     } catch (Dali::DaliException e) {
99135       {
99136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99137       };
99138     } catch (...) {
99139       {
99140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99141       };
99142     }
99143   }
99144 }
99145
99146 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
99147   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
99148   char * jresult = SWIG_csharp_string_callback((const char *)result);
99149   return jresult;
99150 }
99151
99152 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
99153   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
99154   return result;
99155 }
99156
99157
99158 struct NativeImageSourcePtrHandle
99159 {
99160   NativeImageSourcePtr Ptr;
99161 };
99162
99163 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
99164 {
99165   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99166   return (NativeImageInterface*)(arg1);
99167 }
99168
99169 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
99170 {
99171   void* jresult;
99172   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
99173   {
99174     try {
99175       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
99176     }
99177     catch (std::out_of_range & e) {
99178       {
99179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99180       };
99181     }
99182     catch (std::exception & e) {
99183       {
99184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99185       };
99186     }
99187     catch (Dali::DaliException e) {
99188       {
99189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99190       };
99191     }
99192     catch (...) {
99193       {
99194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99195       };
99196     }
99197   }
99198   jresult = (void *)handle;
99199   return jresult;
99200 }
99201
99202 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99203 {
99204   void* jresult;
99205   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99206   jresult = (void*)( handle->Ptr.Get() );
99207   return jresult;
99208 }
99209
99210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99211   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99212   {
99213     try {
99214       delete arg1;
99215     }
99216     catch (std::out_of_range & e) {
99217       {
99218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99219       };
99220     }
99221     catch (std::exception & e) {
99222       {
99223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99224       };
99225     }
99226     catch (Dali::DaliException e) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99229       };
99230     }
99231     catch (...) {
99232       {
99233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99234       };
99235     }
99236   }
99237 }
99238
99239 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99240 {
99241   void* jresult;
99242   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99243   uint16_t* arg2 = (uint16_t*)(jarg2);
99244   uint16_t* arg3 = (uint16_t*)(jarg3);
99245   uint16_t* arg4 = (uint16_t*)(jarg4);
99246   {
99247     try {
99248       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99249     }
99250     catch (std::out_of_range & e) {
99251       {
99252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99253       };
99254     }
99255     catch (std::exception & e) {
99256       {
99257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99258       };
99259     }
99260     catch (Dali::DaliException e) {
99261       {
99262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99263       };
99264     }
99265     catch (...) {
99266       {
99267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99268       };
99269     }
99270   }
99271   return jresult;
99272 }
99273
99274 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99275 {
99276   bool jresult;
99277   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99278
99279   {
99280     try {
99281       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99282     }
99283     catch (std::out_of_range & e) {
99284       {
99285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99286       };
99287     }
99288     catch (std::exception & e) {
99289       {
99290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99291       };
99292     }
99293     catch (Dali::DaliException e) {
99294       {
99295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99296       };
99297     }
99298     catch (...) {
99299       {
99300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99301       };
99302     }
99303   }
99304   return jresult;
99305 }
99306
99307
99308 #ifdef __cplusplus
99309 }
99310 #endif